TWriteDatabase::getWriteSource() - Code Metrics - alex-kalanis/kw_mapper - Measure and Improve Code Quality continuously with Scrutinizer

TWriteDatabase::getWriteSource() A
last analyzed 2025-05-11 16:44 UTC

↳ Parent: TWriteDatabase

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	1
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	1
rs	10

<?php

namespace kalanis\kw_mapper\Mappers\Database;


use kalanis\kw_mapper\Interfaces\IQueryBuilder;
use kalanis\kw_mapper\MapperException;
use kalanis\kw_mapper\Mappers\Shared\TEntityChanged;
use kalanis\kw_mapper\Records\ARecord;
use kalanis\kw_mapper\Records\TFill;
use kalanis\kw_mapper\Storage\Database;


/**
 * Trait TWriteDatabase
 * @package kalanis\kw_mapper\Mappers\Database
 * Separated write DB entry without need to reload mapper
 *
 * Contains only operations for writing into DB
 */
trait TWriteDatabase
{
    use TEntityChanged;
    use TFill;

    protected string $writeSource = '';
    protected Database\ASQL $writeDatabase;
    protected Database\Dialects\ADialect $writeDialect;
    protected Database\QueryBuilder $writeQueryBuilder;

    /**
     * @throws MapperException
     */
    public function initTWriteDatabase(): void
    {
        $this->writeDatabase = $this->getWriteDatabase();
        $this->writeDialect = $this->getWriteDialect($this->writeDatabase);
        $this->writeQueryBuilder = $this->getWriteQueryBuilder($this->writeDialect);
    }

    protected function setWriteSource(string $writeSource): void
    {
        $this->writeSource = $writeSource;
    }

    protected function getWriteSource(): string
    {
        return $this->writeSource;
    }

    /**
     * @throws MapperException
     * @return Database\ADatabase
     */
    protected function getWriteDatabase(): Database\ADatabase
    {
        return Database\DatabaseSingleton::getInstance()->getDatabase(
            Database\ConfigStorage::getInstance()->getConfig($this->getWriteSource())
        );
    }

    /**
     * @param Database\ADatabase $database
     * @throws MapperException
     * @return Database\Dialects\ADialect
     */
    protected function getWriteDialect(Database\ADatabase $database): Database\Dialects\ADialect
    {
        return Database\Dialects\Factory::getInstance()->getDialectClass($database->languageDialect());
    }

    protected function getWriteQueryBuilder(Database\Dialects\ADialect $dialect): Database\QueryBuilder
    {
        return new Database\QueryBuilder($dialect);
    }

    /**
     * @param ARecord $record
     * @throws MapperException
     * @return bool
     */
    protected function insertRecord(ARecord $record): bool
    {
        $writeQueryBuilder = clone $this->writeQueryBuilder;
        $writeQueryBuilder->clear();
        $writeQueryBuilder->setBaseTable($record->getMapper()->getAlias());
        $relations = $record->getMapper()->getRelations();

        foreach ($record as $key => $item) {
            if (isset($relations[$key]) && $this->ifEntryChanged($record->getEntry($key))) {
                $writeQueryBuilder->addProperty(
                    $record->getMapper()->getAlias(),
                    $relations[$key],
                    $item
                );
            }
        }

        if (empty($writeQueryBuilder->getProperties())) {
            return false;
        }

        return $this->writeDatabase->exec(
            strval($this->writeDialect->insert($writeQueryBuilder)),
            $writeQueryBuilder->getParams()
        );
    }

    /**
     * @param ARecord $record
     * @throws MapperException
     * @return bool
     */
    protected function updateRecord(ARecord $record): bool
    {
        if ($this->updateRecordByPk($record)) {
            return true;
        }
        $writeQueryBuilder = clone $this->writeQueryBuilder;
        $writeQueryBuilder->clear();
        $writeQueryBuilder->setBaseTable($record->getMapper()->getAlias());
        $relations = $record->getMapper()->getRelations();

        foreach ($record as $key => $item) {
            if (isset($relations[$key]) && $this->ifEntryChanged($record->getEntry($key))) {
                if ($record->getEntry($key)->isFromStorage()) {
                    $writeQueryBuilder->addCondition(
                        $record->getMapper()->getAlias(),
                        $relations[$key],
                        IQueryBuilder::OPERATION_EQ,
                        $item
                    );
                } else {
                    $writeQueryBuilder->addProperty(
                        $record->getMapper()->getAlias(),
                        $relations[$key],
                        $item
                    );
                }
            }
        }

        if (empty($writeQueryBuilder->getConditions())) { /// this one is questionable - I really want to update everything?
            return false;
        }
        if (empty($writeQueryBuilder->getProperties())) {
            return false;
        }

        return $this->writeDatabase->exec(
            strval($this->writeDialect->update($writeQueryBuilder)),
            $writeQueryBuilder->getParams()
        );
    }

    /**
     * @param ARecord $record
     * @throws MapperException
     * @return bool
     */
    protected function updateRecordByPk(ARecord $record): bool
    {
        if (empty($record->getMapper()->getPrimaryKeys())) {
            return false;
        }

        $writeQueryBuilder = clone $this->writeQueryBuilder;
        $writeQueryBuilder->clear();
        $writeQueryBuilder->setBaseTable($record->getMapper()->getAlias());
        $relations = $record->getMapper()->getRelations();

        foreach ($record->getMapper()->getPrimaryKeys() as $key) {
            try {
                if (isset($relations[$key])) {
                    $entry = $record->getEntry($key);
                    if ($entry->isFromStorage() && $this->ifEntryChanged($record->getEntry($key))) {
                        $writeQueryBuilder->addCondition(
                            $record->getMapper()->getAlias(),
                            $relations[$key],
                            IQueryBuilder::OPERATION_EQ,
                            $entry->getData()
                        );
                    }
                }
            } catch (MapperException $ex) {
                return false;
            }
        }

        if (empty($writeQueryBuilder->getConditions())) { // no conditions, nothing in PKs - back to normal system
            return false;
        }

        foreach ($record as $key => $item) {
            if (isset($relations[$key])) {
                $entry = $record->getEntry($key);
                if (
                    !in_array($key, $record->getMapper()->getPrimaryKeys())
                    && !$entry->isFromStorage()
                    && $this->ifEntryChanged($record->getEntry($key))
                ) {
                    $writeQueryBuilder->addProperty($record->getMapper()->getAlias(), $relations[$key], $item);
                }
            }
        }

        if (empty($writeQueryBuilder->getProperties())) {
            return false;
        }

        return $this->writeDatabase->exec(
            strval($this->writeDialect->update($writeQueryBuilder)),
            $writeQueryBuilder->getParams()
        );
    }

    /**
     * @param ARecord $record
     * @throws MapperException
     * @return bool
     */
    protected function deleteRecord(ARecord $record): bool
    {
        if ($this->deleteRecordByPk($record)) {
            return true;
        }

        $writeQueryBuilder = clone $this->writeQueryBuilder;
        $writeQueryBuilder->clear();
        $writeQueryBuilder->setBaseTable($record->getMapper()->getAlias());
        $relations = $record->getMapper()->getRelations();

        foreach ($record as $key => $item) {
            if (isset($relations[$key]) && $this->ifEntryChanged($record->getEntry($key))) {
                $writeQueryBuilder->addCondition(
                    $record->getMapper()->getAlias(),
                    $relations[$key],
                    IQueryBuilder::OPERATION_EQ,
                    $item
                );
            }
        }

        if (empty($writeQueryBuilder->getConditions())) { /// this one is necessary - delete everything? do it yourself - and manually!
            return false;
        }

        return $this->writeDatabase->exec(
            strval($this->writeDialect->delete($writeQueryBuilder)),
            $writeQueryBuilder->getParams()
        );
    }

    /**
     * @param ARecord $record
     * @throws MapperException
     * @return bool
     */
    protected function deleteRecordByPk(ARecord $record): bool
    {
        if (empty($record->getMapper()->getPrimaryKeys())) {
            return false;
        }

        $writeQueryBuilder = clone $this->writeQueryBuilder;
        $writeQueryBuilder->clear();
        $writeQueryBuilder->setBaseTable($record->getMapper()->getAlias());
        $relations = $record->getMapper()->getRelations();

        foreach ($record->getMapper()->getPrimaryKeys() as $key) {
            try {
                if (isset($relations[$key]) && $this->ifEntryChanged($record->getEntry($key))) {
                    $writeQueryBuilder->addCondition(
                        $record->getMapper()->getAlias(),
                        $relations[$key],
                        IQueryBuilder::OPERATION_EQ,
                        $record->offsetGet($key)
                    );
                }
            } catch (MapperException $ex) {
                return false;
            }
        }

        if (empty($writeQueryBuilder->getConditions())) { // no conditions, nothing in PKs - back to normal system
            return false;
        }

        return $this->writeDatabase->exec(
            strval($this->writeDialect->delete($writeQueryBuilder)),
            $writeQueryBuilder->getParams()
        );
    }
}


1		<?php
2
3		namespace kalanis\kw_mapper\Mappers\Database;
4
5
6		use kalanis\kw_mapper\Interfaces\IQueryBuilder;
7		use kalanis\kw_mapper\MapperException;
8		use kalanis\kw_mapper\Mappers\Shared\TEntityChanged;
9		use kalanis\kw_mapper\Records\ARecord;
10		use kalanis\kw_mapper\Records\TFill;
11		use kalanis\kw_mapper\Storage\Database;
12
13
14		/**
15		* Trait TWriteDatabase
16		* @package kalanis\kw_mapper\Mappers\Database
17		* Separated write DB entry without need to reload mapper
18		*
19		* Contains only operations for writing into DB
20		*/
21		trait TWriteDatabase
22		{
23		use TEntityChanged;
24		use TFill;
25
26		protected string $writeSource = '';
27		protected Database\ASQL $writeDatabase;
28		protected Database\Dialects\ADialect $writeDialect;
29		protected Database\QueryBuilder $writeQueryBuilder;
30
31		/**
32		* @throws MapperException
33		*/
34	18	public function initTWriteDatabase(): void
35		{
36	18	$this->writeDatabase = $this->getWriteDatabase();
37	18	$this->writeDialect = $this->getWriteDialect($this->writeDatabase);
38	18	$this->writeQueryBuilder = $this->getWriteQueryBuilder($this->writeDialect);
39		}
40
41	4	protected function setWriteSource(string $writeSource): void
42		{
43	4	$this->writeSource = $writeSource;
44		}
45
46	4	protected function getWriteSource(): string
47		{
48	4	return $this->writeSource;
49		}
50
51		/**
52		* @throws MapperException
53		* @return Database\ADatabase
54		*/
55	18	protected function getWriteDatabase(): Database\ADatabase
56		{
57	18	return Database\DatabaseSingleton::getInstance()->getDatabase(
58	18	Database\ConfigStorage::getInstance()->getConfig($this->getWriteSource())
59	18	);
60		}
61
62		/**
63		* @param Database\ADatabase $database
64		* @throws MapperException
65		* @return Database\Dialects\ADialect
66		*/
67	18	protected function getWriteDialect(Database\ADatabase $database): Database\Dialects\ADialect
68		{
69	18	return Database\Dialects\Factory::getInstance()->getDialectClass($database->languageDialect());
70		}
71
72	18	protected function getWriteQueryBuilder(Database\Dialects\ADialect $dialect): Database\QueryBuilder
73		{
74	18	return new Database\QueryBuilder($dialect);
75		}
76
77		/**
78		* @param ARecord $record
79		* @throws MapperException
80		* @return bool
81		*/
82	9	protected function insertRecord(ARecord $record): bool
83		{
84	9	$writeQueryBuilder = clone $this->writeQueryBuilder;
85	9	$writeQueryBuilder->clear();
86	9	$writeQueryBuilder->setBaseTable($record->getMapper()->getAlias());
87	9	$relations = $record->getMapper()->getRelations();
88
89	9	foreach ($record as $key => $item) {
90	9	if (isset($relations[$key]) && $this->ifEntryChanged($record->getEntry($key))) {
91	7	$writeQueryBuilder->addProperty(
92	7	$record->getMapper()->getAlias(),
93	7	$relations[$key],
94	7	$item
95	7	);
96		}
97		}
98
99	9	if (empty($writeQueryBuilder->getProperties())) {
100	2	return false;
101		}
102
103	7	return $this->writeDatabase->exec(
104	7	strval($this->writeDialect->insert($writeQueryBuilder)),
105	7	$writeQueryBuilder->getParams()
106	7	);
107		}
108
109		/**
110		* @param ARecord $record
111		* @throws MapperException
112		* @return bool
113		*/
114	9	protected function updateRecord(ARecord $record): bool
115		{
116	9	if ($this->updateRecordByPk($record)) {
117	4	return true;
118		}
119	8	$writeQueryBuilder = clone $this->writeQueryBuilder;
120	8	$writeQueryBuilder->clear();
121	8	$writeQueryBuilder->setBaseTable($record->getMapper()->getAlias());
122	8	$relations = $record->getMapper()->getRelations();
123
124	8	foreach ($record as $key => $item) {
125	8	if (isset($relations[$key]) && $this->ifEntryChanged($record->getEntry($key))) {
126	8	if ($record->getEntry($key)->isFromStorage()) {
127	6	$writeQueryBuilder->addCondition(
128	6	$record->getMapper()->getAlias(),
129	6	$relations[$key],
130	6	IQueryBuilder::OPERATION_EQ,
131	6	$item
132	6	);
133		} else {
134	6	$writeQueryBuilder->addProperty(
135	6	$record->getMapper()->getAlias(),
136	6	$relations[$key],
137	6	$item
138	6	);
139		}
140		}
141		}
142
143	8	if (empty($writeQueryBuilder->getConditions())) { /// this one is questionable - I really want to update everything?
144	2	return false;
145		}
146	6	if (empty($writeQueryBuilder->getProperties())) {
147	2	return false;
148		}
149
150	4	return $this->writeDatabase->exec(
151	4	strval($this->writeDialect->update($writeQueryBuilder)),
152	4	$writeQueryBuilder->getParams()
153	4	);
154		}
155
156		/**
157		* @param ARecord $record
158		* @throws MapperException
159		* @return bool
160		*/
161	13	protected function updateRecordByPk(ARecord $record): bool
162		{
163	13	if (empty($record->getMapper()->getPrimaryKeys())) {
164	3	return false;
165		}
166
167	10	$writeQueryBuilder = clone $this->writeQueryBuilder;
168	10	$writeQueryBuilder->clear();
169	10	$writeQueryBuilder->setBaseTable($record->getMapper()->getAlias());
170	10	$relations = $record->getMapper()->getRelations();
171
172	10	foreach ($record->getMapper()->getPrimaryKeys() as $key) {
173		try {
174	10	if (isset($relations[$key])) {
175	10	$entry = $record->getEntry($key);
176	8	if ($entry->isFromStorage() && $this->ifEntryChanged($record->getEntry($key))) {
177	8	$writeQueryBuilder->addCondition(
178	8	$record->getMapper()->getAlias(),
179	8	$relations[$key],
180	8	IQueryBuilder::OPERATION_EQ,
181	8	$entry->getData()
182	8	);
183		}
184		}
185	2	} catch (MapperException $ex) {
186	2	return false;
187		}
188		}
189
190	8	if (empty($writeQueryBuilder->getConditions())) { // no conditions, nothing in PKs - back to normal system
191	5	return false;
192		}
193
194	6	foreach ($record as $key => $item) {
195	6	if (isset($relations[$key])) {
196	6	$entry = $record->getEntry($key);
197		if (
198	6	!in_array($key, $record->getMapper()->getPrimaryKeys())
199	6	&& !$entry->isFromStorage()
200	6	&& $this->ifEntryChanged($record->getEntry($key))
201		) {
202	4	$writeQueryBuilder->addProperty($record->getMapper()->getAlias(), $relations[$key], $item);
203		}
204		}
205		}
206
207	6	if (empty($writeQueryBuilder->getProperties())) {
208	2	return false;
209		}
210
211	4	return $this->writeDatabase->exec(
212	4	strval($this->writeDialect->update($writeQueryBuilder)),
213	4	$writeQueryBuilder->getParams()
214	4	);
215		}
216
217		/**
218		* @param ARecord $record
219		* @throws MapperException
220		* @return bool
221		*/
222	9	protected function deleteRecord(ARecord $record): bool
223		{
224	9	if ($this->deleteRecordByPk($record)) {
225	3	return true;
226		}
227
228	6	$writeQueryBuilder = clone $this->writeQueryBuilder;
229	6	$writeQueryBuilder->clear();
230	6	$writeQueryBuilder->setBaseTable($record->getMapper()->getAlias());
231	6	$relations = $record->getMapper()->getRelations();
232
233	6	foreach ($record as $key => $item) {
234	6	if (isset($relations[$key]) && $this->ifEntryChanged($record->getEntry($key))) {
235	4	$writeQueryBuilder->addCondition(
236	4	$record->getMapper()->getAlias(),
237	4	$relations[$key],
238	4	IQueryBuilder::OPERATION_EQ,
239	4	$item
240	4	);
241		}
242		}
243
244	6	if (empty($writeQueryBuilder->getConditions())) { /// this one is necessary - delete everything? do it yourself - and manually!
245	2	return false;
246		}
247
248	4	return $this->writeDatabase->exec(
249	4	strval($this->writeDialect->delete($writeQueryBuilder)),
250	4	$writeQueryBuilder->getParams()
251	4	);
252		}
253
254		/**
255		* @param ARecord $record
256		* @throws MapperException
257		* @return bool
258		*/
259	13	protected function deleteRecordByPk(ARecord $record): bool
260		{
261	13	if (empty($record->getMapper()->getPrimaryKeys())) {
262	4	return false;
263		}
264
265	10	$writeQueryBuilder = clone $this->writeQueryBuilder;
266	10	$writeQueryBuilder->clear();
267	10	$writeQueryBuilder->setBaseTable($record->getMapper()->getAlias());
268	10	$relations = $record->getMapper()->getRelations();
269
270	10	foreach ($record->getMapper()->getPrimaryKeys() as $key) {
271		try {
272	10	if (isset($relations[$key]) && $this->ifEntryChanged($record->getEntry($key))) {
273	8	$writeQueryBuilder->addCondition(
274	8	$record->getMapper()->getAlias(),
275	8	$relations[$key],
276	8	IQueryBuilder::OPERATION_EQ,
277	8	$record->offsetGet($key)
278	8	);
279		}
280	2	} catch (MapperException $ex) {
281	2	return false;
282		}
283		}
284
285	8	if (empty($writeQueryBuilder->getConditions())) { // no conditions, nothing in PKs - back to normal system
286	5	return false;
287		}
288
289	3	return $this->writeDatabase->exec(
290	3	strval($this->writeDialect->delete($writeQueryBuilder)),
291	3	$writeQueryBuilder->getParams()
292	3	);
293		}
294		}
295

alex-kalanis / kw_mapper

TWriteDatabase::getWriteSource() A last analyzed 2025-05-11 16:44 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

TWriteDatabase::getWriteSource() A
last analyzed 2025-05-11 16:44 UTC