DatabaseController::unsetSubKey() - Code Metrics - Inspection of "Feature/composer and namespaces" - AOEpeople/t3deploy - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#4)

by Felix

created 2018-03-19 12:21 UTC

DatabaseController::unsetSubKey() B

↳ Parent: DatabaseController

Complexity

Conditions	7
Paths	2

Size

Total Lines	13
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	7

Importance

Changes

Metric	Value
dl	0
loc	13
ccs	7
cts	7
cp	1
rs	8.2222
c	0
b	0
f	0
cc	7
eloc	7
nc	2
nop	4
crap	7

<?php
namespace Aoe\T3deploy\Controller;

/***************************************************************
 *  Copyright notice
 *
 *  (c) 2018 AOE GmbH <[email protected]>
 *
 *  All rights reserved
 *
 *  This script is part of the TYPO3 project. The TYPO3 project is
 *  free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  The GNU General Public License can be found at
 *  http://www.gnu.org/copyleft/gpl.html.
 *
 *  This script is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  This copyright notice MUST APPEAR in all copies of the script!
 ***************************************************************/

use TYPO3\CMS\Core\Category\CategoryRegistry;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Extbase\Object\ObjectManager;
use TYPO3\CMS\Install\Service\SqlExpectedSchemaService;
use TYPO3\CMS\Install\Service\SqlSchemaMigrationService;

/**
 * Controller that handles database actions of the t3deploy process inside TYPO3.
 *
 * @package t3deploy
 */
class DatabaseController
{
    /*
     * List of all possible update types:
     *  + add, change, drop, create_table, change_table, drop_table, clear_table
     * List of all sensible update types:
     *  + add, change, create_table, change_table
     */
    const UpdateTypes_List = 'add,change,create_table,change_table';

    const RemoveTypes_list = 'drop,drop_table,clear_table';


    /**
     * @var \TYPO3\CMS\Install\Service\SqlSchemaMigrationService
     */
    protected $schemaMigrationService;

    /**
     * @var \TYPO3\CMS\Install\Service\SqlExpectedSchemaService
     */
    protected $expectedSchemaService;

    /**
     * @var \TYPO3\CMS\Core\Category\CategoryRegistry
     */
    protected $categoryRegistry;

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

    /**
     * Creates this object.
     */
    public function __construct()
    {
        /** @var ObjectManager $objectManager */
        $objectManager = GeneralUtility::makeInstance(ObjectManager::class);

        $this->schemaMigrationService = $objectManager->get(SqlSchemaMigrationService::class);
        $this->expectedSchemaService = $objectManager->get(SqlExpectedSchemaService::class);
        $this->categoryRegistry = $objectManager->get(CategoryRegistry::class);

        $this->setConsideredTypes($this->getUpdateTypes());
    }

    /**
     * Sets the types considered to be executed (updates and/or removal).
     *
     * @param array $consideredTypes
     * @return void
     * @see updateStructureAction()
     */
    public function setConsideredTypes(array $consideredTypes)
    {
        $this->consideredTypes = $consideredTypes;
    }

    /**
     * Adds considered types.
     *
     * @param array $consideredTypes
     * @return void
     * @see updateStructureAction()
     */
    public function addConsideredTypes(array $consideredTypes)
    {
        $this->consideredTypes = array_unique(
            array_merge($this->consideredTypes, $consideredTypes)
        );
    }

    /**
     * Removes defined types from considered types.
     *
     * @param array $removals
     * @return void
     * @see updateStructureAction()
     */
    public function removeConsideredTypes(array $removals)
    {
        $this->consideredTypes = array_diff($this->consideredTypes, $removals);
    }

    /**
     * Updates the database structure.
     *
     * @param array $arguments Optional arguments passed to this action
     * @return string
     * @throws \Exception
     */
    public function updateStructureAction(array $arguments)
    {
        $isExecuteEnabled = (isset($arguments['--execute']) || isset($arguments['-e']));
        $isRemovalEnabled = (isset($arguments['--remove']) || isset($arguments['-r']));
        $isModifyKeysEnabled = isset($arguments['--drop-keys']);

        $result = $this->executeUpdateStructureUntilNoMoreChanges($arguments, $isModifyKeysEnabled);

        if(isset($arguments['--dump-file'])) {
            $dumpFileName = $arguments['--dump-file'][0];

            if (!file_exists(dirname($dumpFileName))) {
                throw new \InvalidArgumentException(sprintf(
                    'directory %s does not exist or is not readable', dirname($dumpFileName)
                ));
            }

            if (file_exists($dumpFileName) && !is_writable($dumpFileName)) {
                throw new \InvalidArgumentException(sprintf(
                    'file %s is not writable', $dumpFileName
                ));
            }

            file_put_contents($dumpFileName, $result);
            $result = sprintf("Output written to %s\n", $dumpFileName);
        }

        if ($isExecuteEnabled) {
            $result .= ($result ? PHP_EOL : '')
                            . $this->executeUpdateStructureUntilNoMoreChanges($arguments, $isRemovalEnabled);
        }

        return $result;
    }

    /**
     * call executeUpdateStructure until there are no more changes.
     *
     * The install tool sometimes relies on the user hitting the "update" button multiple times. This method
     * encapsulates that behaviour.
     *
     * @see executeUpdateStructure()
     * @param array $arguments
     * @param bool $allowKeyModifications
     * @return string
     * @throws \Exception
     */
    protected function executeUpdateStructureUntilNoMoreChanges(array $arguments, $allowKeyModifications = false)
    {
        $result = '';
        $iteration = 1;
        $loopResult = '';

        do {
            $previousLoopResult = $loopResult;
            $loopResult = $this->executeUpdateStructure($arguments, $allowKeyModifications);

            if ($loopResult == $previousLoopResult) {
                break;
            }

            $result .= sprintf("\n# Iteration %d\n%s", $iteration++, $loopResult);

            if ($iteration > 10) {
                $result .= "\nGiving up after 10 iterations.";
                break;
            }
        } while (!empty($loopResult));

        return $result;
    }

    /**
     * Executes the database structure updates.
     *
     * @param array $arguments Optional arguments passed to this action
     * @param boolean $allowKeyModifications Whether to allow key modifications
     * @return string
     * @throws \Exception
     */
    protected function executeUpdateStructure(array $arguments, $allowKeyModifications = false)
    {
        $result = '';

        $isExecuteEnabled = (isset($arguments['--execute']) || isset($arguments['-e']));
        $isRemovalEnabled = (isset($arguments['--remove']) || isset($arguments['-r']));
        $isVerboseEnabled = (isset($arguments['--verbose']) || isset($arguments['-v']));
        $hasExcludes      = (isset($arguments['--excludes']) && is_array($arguments['--excludes']));

        $changes = $this->schemaMigrationService->getUpdateSuggestions(
            $this->getStructureDifferencesForUpdate($allowKeyModifications)
        );

        if ($isRemovalEnabled) {
                // Disable the delete prefix, thus tables and fields can be removed directly:
            $this->schemaMigrationService->setDeletedPrefixKey('');

                // Add types considered for removal:
            $this->addConsideredTypes($this->getRemoveTypes());
                // Merge update suggestions:
            $removals = $this->schemaMigrationService->getUpdateSuggestions(
                $this->getStructureDifferencesForRemoval($allowKeyModifications),
                'remove'
            );
            $changes = array_merge($changes, $removals);
        }

        if ($hasExcludes) {
            $excludes = explode(',', $arguments['--excludes'][0]);
            $this->removeConsideredTypes($excludes);
        }

        if ($isExecuteEnabled || $isVerboseEnabled) {
            $statements = [];

            // Concatenates all statements:
            foreach ($this->consideredTypes as $consideredType) {
                if (isset($changes[$consideredType]) && is_array($changes[$consideredType])) {
                    $statements += $changes[$consideredType];
                }
            }

            $statements = $this->sortStatements($statements);

            if ($isExecuteEnabled) {
                foreach ($statements as $statement) {
                    $GLOBALS['TYPO3_DB']->admin_query($statement);
                }
            }

            if ($isVerboseEnabled) {
                $result = implode(PHP_EOL, $statements);
            }
        }

        $this->checkChangesSyntax($result);

        return $result;
    }

    /**
     * performs some basic checks on the database changes to identify most common errors
     *
     * @param string $changes the changes to check
     * @throws \Exception if the file seems to contain bad data
     */
    protected function checkChangesSyntax($changes)
    {
        if (strlen($changes) < 10) return;

        $checked = substr(ltrim($changes), 0, 10);

        if ($checked != trim(strtoupper($checked))) {
            throw new \Exception(
                'Changes for schema_up seem to contain weird data, it starts with this:' . PHP_EOL
                    . substr($changes, 0, 200).PHP_EOL.'==================================' . PHP_EOL
                    . 'If the file is ok, please add your conditions to file '
                    . 'res/extensions/t3deploy/classes/class.tx_t3deploy_databaseController.php in t3deploy.'
            );
        }
    }

    /**
     * Removes key modifications that will cause errors.
     *
     * @param array $differences The differences to be cleaned up
     * @return array The cleaned differences
     */
    protected function removeKeyModifications(array $differences)
    {
        $differences = $this->unsetSubKey($differences, 'extra', 'keys', 'whole_table');
        $differences = $this->unsetSubKey($differences, 'diff', 'keys');

        return $differences;
    }

    /**
     * Unsets a subkey in a given differences array.
     *
     * @param array $differences
     * @param string $type e.g. extra or diff
     * @param string $subKey e.g. keys or fields
     * @param string $exception e.g. whole_table that stops the removal
     * @return array
     */
    protected function unsetSubKey(array $differences, $type, $subKey, $exception = '')
    {
        if (isset($differences[$type])) {
            foreach ($differences[$type] as $table => $information) {
                $isException = ($exception && isset($information[$exception]) && $information[$exception]);
                if (isset($information[$subKey]) && $isException === false) {
                    unset($differences[$type][$table][$subKey]);
                }
            }
        }

        return $differences;
    }

    /**
     * Gets the differences in the database structure by comparing
     * the current structure with the SQL definitions of all extensions
     * and the TYPO3 core in t3lib/stddb/tables.sql.
     *
     * This method searches for fields/tables to be added/updated.
     *
     * @param boolean $allowKeyModifications Whether to allow key modifications
     * @return array The database statements to update the structure
     */
    protected function getStructureDifferencesForUpdate($allowKeyModifications = false)
    {
        $differences = $this->schemaMigrationService->getDatabaseExtra(
            $this->getDefinedFieldDefinitions(),
            $this->schemaMigrationService->getFieldDefinitions_database()
        );

        if (!$allowKeyModifications) {
            $differences = $this->removeKeyModifications($differences);
        }

        return $differences;
    }

    /**
     * Gets the differences in the database structure by comparing
     * the current structure with the SQL definitions of all extensions
     * and the TYPO3 core in t3lib/stddb/tables.sql.
     *
     * This method searches for fields/tables to be removed.
     *
     * @param boolean $allowKeyModifications Whether to allow key modifications
     * @return array The database statements to update the structure
     */
    protected function getStructureDifferencesForRemoval($allowKeyModifications = false)
    {
        $differences = $this->schemaMigrationService->getDatabaseExtra(
            $this->schemaMigrationService->getFieldDefinitions_database(),
            $this->getDefinedFieldDefinitions()
        );

        if (!$allowKeyModifications) {
            $differences = $this->removeKeyModifications($differences);
        }

        return $differences;
    }

    /**
     * Gets the defined field definitions from the ext_tables.sql files.
     *
     * @return array The accordant definitions
     */
    protected function getDefinedFieldDefinitions()
    {
        $cacheTables = $this->categoryRegistry->getDatabaseTableDefinitions();
        $content = $this->schemaMigrationService->getFieldDefinitions_fileContent(
            implode(chr(10), $this->getAllRawStructureDefinitions()) . $cacheTables
        );
        return $content;
    }

    /**
     * Gets all structure definitions of extensions the TYPO3 Core.
     *
     * @return array All structure definitions
     */
    protected function getAllRawStructureDefinitions()
    {

        $expectedSchemaString = $this->expectedSchemaService->getTablesDefinitionString(true);
        $rawDefinitions = $this->schemaMigrationService->getStatementArray($expectedSchemaString, true);

        return $rawDefinitions;
    }

    /**
     * Gets the defined update types.
     *
     * @return array
     */
    protected function getUpdateTypes()
    {
        return \TYPO3\CMS\Core\Utility\GeneralUtility::trimExplode(',', self::UpdateTypes_List, true);
    }

    /**
     * Gets the defined remove types.
     *
     * @return array
     */
    protected function getRemoveTypes()
    {
        return \TYPO3\CMS\Core\Utility\GeneralUtility::trimExplode(',', self::RemoveTypes_list, true);
    }

    /**
     * sorts the statements in an array
     *
     * @param array $statements
     * @return array
     */
    protected function sortStatements($statements)
    {
        $newStatements = [];

        foreach($statements as $key=>$statement) {
            if($this->isDropKeyStatement($statement)) {
                $newStatements[$key] = $statement;
            }
        }

        foreach($statements as $key=>$statement) {
            // writing the statement again, does not change its position
            // this saves a condition check
            $newStatements[$key] = $statement;
        }

        return $newStatements;
    }

    /**
     * returns true if the given statement looks as if it drops a (primary) key
     *
     * @param $statement
     * @return bool
     */
    protected function isDropKeyStatement($statement)
    {
        return strpos($statement, ' DROP ') !== false && strpos($statement, ' KEY') !== false;
    }
}


1		<?php
2		namespace Aoe\T3deploy\Controller;
3
4		/***************************************************************
5		* Copyright notice
6		*
7		* (c) 2018 AOE GmbH <[email protected]>
8		*
9		* All rights reserved
10		*
11		* This script is part of the TYPO3 project. The TYPO3 project is
12		* free software; you can redistribute it and/or modify
13		* it under the terms of the GNU General Public License as published by
14		* the Free Software Foundation; either version 3 of the License, or
15		* (at your option) any later version.
16		*
17		* The GNU General Public License can be found at
18		* http://www.gnu.org/copyleft/gpl.html.
19		*
20		* This script is distributed in the hope that it will be useful,
21		* but WITHOUT ANY WARRANTY; without even the implied warranty of
22		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23		* GNU General Public License for more details.
24		*
25		* This copyright notice MUST APPEAR in all copies of the script!
26		***************************************************************/
27
28		use TYPO3\CMS\Core\Category\CategoryRegistry;
29		use TYPO3\CMS\Core\Utility\GeneralUtility;
30		use TYPO3\CMS\Extbase\Object\ObjectManager;
31		use TYPO3\CMS\Install\Service\SqlExpectedSchemaService;
32		use TYPO3\CMS\Install\Service\SqlSchemaMigrationService;
33
34		/**
35		* Controller that handles database actions of the t3deploy process inside TYPO3.
36		*
37		* @package t3deploy
38		*/
39		class DatabaseController
40		{
41		/*
42		* List of all possible update types:
43		* + add, change, drop, create_table, change_table, drop_table, clear_table
44		* List of all sensible update types:
45		* + add, change, create_table, change_table
46		*/
47		const UpdateTypes_List = 'add,change,create_table,change_table';
		0 ignored issues – show Coding Style introduced 2018-01-09 12:24 UTC by Report Bug Copy Issue Report Constant UpdateTypes_List should be defined in uppercase Loading history...
48		const RemoveTypes_list = 'drop,drop_table,clear_table';
		0 ignored issues – show Coding Style introduced 2018-01-09 12:24 UTC by Report Bug Copy Issue Report Constant RemoveTypes_list should be defined in uppercase Loading history...
49
50		/**
51		* @var \TYPO3\CMS\Install\Service\SqlSchemaMigrationService
52		*/
53		protected $schemaMigrationService;
54
55		/**
56		* @var \TYPO3\CMS\Install\Service\SqlExpectedSchemaService
57		*/
58		protected $expectedSchemaService;
59
60		/**
61		* @var \TYPO3\CMS\Core\Category\CategoryRegistry
62		*/
63		protected $categoryRegistry;
64
65		/**
66		* @var array
67		*/
68		protected $consideredTypes;
69
70		/**
71		* Creates this object.
72		*/
73	5	public function __construct()
74		{
75		/** @var ObjectManager $objectManager */
76	5	$objectManager = GeneralUtility::makeInstance(ObjectManager::class);
77
78	5	$this->schemaMigrationService = $objectManager->get(SqlSchemaMigrationService::class);
79	5	$this->expectedSchemaService = $objectManager->get(SqlExpectedSchemaService::class);
80	5	$this->categoryRegistry = $objectManager->get(CategoryRegistry::class);
81
82	5	$this->setConsideredTypes($this->getUpdateTypes());
83	5	}
84
85		/**
86		* Sets the types considered to be executed (updates and/or removal).
87		*
88		* @param array $consideredTypes
89		* @return void
90		* @see updateStructureAction()
91		*/
92	5	public function setConsideredTypes(array $consideredTypes)
93		{
94	5	$this->consideredTypes = $consideredTypes;
95	5	}
96
97		/**
98		* Adds considered types.
99		*
100		* @param array $consideredTypes
101		* @return void
102		* @see updateStructureAction()
103		*/
104	2	public function addConsideredTypes(array $consideredTypes)
105		{
106	2	$this->consideredTypes = array_unique(
107	2	array_merge($this->consideredTypes, $consideredTypes)
108		);
109	2	}
110
111		/**
112		* Removes defined types from considered types.
113		*
114		* @param array $removals
115		* @return void
116		* @see updateStructureAction()
117		*/
118		public function removeConsideredTypes(array $removals)
119		{
120		$this->consideredTypes = array_diff($this->consideredTypes, $removals);
121		}
122
123		/**
124		* Updates the database structure.
125		*
126		* @param array $arguments Optional arguments passed to this action
127		* @return string
128		* @throws \Exception
129		*/
130	5	public function updateStructureAction(array $arguments)
131		{
132	5	$isExecuteEnabled = (isset($arguments['--execute']) \|\| isset($arguments['-e']));
133	5	$isRemovalEnabled = (isset($arguments['--remove']) \|\| isset($arguments['-r']));
134	5	$isModifyKeysEnabled = isset($arguments['--drop-keys']);
135
136	5	$result = $this->executeUpdateStructureUntilNoMoreChanges($arguments, $isModifyKeysEnabled);
137
138	5	if(isset($arguments['--dump-file'])) {
139	1	$dumpFileName = $arguments['--dump-file'][0];
140
141	1	if (!file_exists(dirname($dumpFileName))) {
142		throw new \InvalidArgumentException(sprintf(
143		'directory %s does not exist or is not readable', dirname($dumpFileName)
144		));
145		}
146
147	1	if (file_exists($dumpFileName) && !is_writable($dumpFileName)) {
148		throw new \InvalidArgumentException(sprintf(
149		'file %s is not writable', $dumpFileName
150		));
151		}
152
153	1	file_put_contents($dumpFileName, $result);
154	1	$result = sprintf("Output written to %s\n", $dumpFileName);
155		}
156
157	5	if ($isExecuteEnabled) {
158	2	$result .= ($result ? PHP_EOL : '')
159	2	. $this->executeUpdateStructureUntilNoMoreChanges($arguments, $isRemovalEnabled);
160		}
161
162	5	return $result;
163		}
164
165		/**
166		* call executeUpdateStructure until there are no more changes.
167		*
168		* The install tool sometimes relies on the user hitting the "update" button multiple times. This method
169		* encapsulates that behaviour.
170		*
171		* @see executeUpdateStructure()
172		* @param array $arguments
173		* @param bool $allowKeyModifications
174		* @return string
175		* @throws \Exception
176		*/
177	5	protected function executeUpdateStructureUntilNoMoreChanges(array $arguments, $allowKeyModifications = false)
178		{
179	5	$result = '';
180	5	$iteration = 1;
181	5	$loopResult = '';
182
183		do {
184	5	$previousLoopResult = $loopResult;
185	5	$loopResult = $this->executeUpdateStructure($arguments, $allowKeyModifications);
186
187	5	if ($loopResult == $previousLoopResult) {
188	5	break;
189		}
190
191	3	$result .= sprintf("\n# Iteration %d\n%s", $iteration++, $loopResult);
192
193	3	if ($iteration > 10) {
194		$result .= "\nGiving up after 10 iterations.";
195		break;
196		}
197	3	} while (!empty($loopResult));
198
199	5	return $result;
200		}
201
202		/**
203		* Executes the database structure updates.
204		*
205		* @param array $arguments Optional arguments passed to this action
206		* @param boolean $allowKeyModifications Whether to allow key modifications
207		* @return string
208		* @throws \Exception
209		*/
210	5	protected function executeUpdateStructure(array $arguments, $allowKeyModifications = false)
211		{
212	5	$result = '';
213
214	5	$isExecuteEnabled = (isset($arguments['--execute']) \|\| isset($arguments['-e']));
215	5	$isRemovalEnabled = (isset($arguments['--remove']) \|\| isset($arguments['-r']));
216	5	$isVerboseEnabled = (isset($arguments['--verbose']) \|\| isset($arguments['-v']));
217	5	$hasExcludes = (isset($arguments['--excludes']) && is_array($arguments['--excludes']));
218
219	5	$changes = $this->schemaMigrationService->getUpdateSuggestions(
220	5	$this->getStructureDifferencesForUpdate($allowKeyModifications)
221		);
222
223	5	if ($isRemovalEnabled) {
224		// Disable the delete prefix, thus tables and fields can be removed directly:
225	2	$this->schemaMigrationService->setDeletedPrefixKey('');
226
227		// Add types considered for removal:
228	2	$this->addConsideredTypes($this->getRemoveTypes());
229		// Merge update suggestions:
230	2	$removals = $this->schemaMigrationService->getUpdateSuggestions(
231	2	$this->getStructureDifferencesForRemoval($allowKeyModifications),
232	2	'remove'
233		);
234	2	$changes = array_merge($changes, $removals);
235		}
236
237	5	if ($hasExcludes) {
238		$excludes = explode(',', $arguments['--excludes'][0]);
239		$this->removeConsideredTypes($excludes);
240		}
241
242	5	if ($isExecuteEnabled \|\| $isVerboseEnabled) {
243	5	$statements = [];
244
245		// Concatenates all statements:
246	5	foreach ($this->consideredTypes as $consideredType) {
247	5	if (isset($changes[$consideredType]) && is_array($changes[$consideredType])) {
248	5	$statements += $changes[$consideredType];
249		}
250		}
251
252	5	$statements = $this->sortStatements($statements);
253
254	5	if ($isExecuteEnabled) {
255	2	foreach ($statements as $statement) {
256	2	$GLOBALS['TYPO3_DB']->admin_query($statement);
257		}
258		}
259
260	5	if ($isVerboseEnabled) {
261	3	$result = implode(PHP_EOL, $statements);
262		}
263		}
264
265	5	$this->checkChangesSyntax($result);
266
267	5	return $result;
268		}
269
270		/**
271		* performs some basic checks on the database changes to identify most common errors
272		*
273		* @param string $changes the changes to check
274		* @throws \Exception if the file seems to contain bad data
275		*/
276	5	protected function checkChangesSyntax($changes)
277		{
278	5	if (strlen($changes) < 10) return;
279
280	3	$checked = substr(ltrim($changes), 0, 10);
281
282	3	if ($checked != trim(strtoupper($checked))) {
283		throw new \Exception(
284		'Changes for schema_up seem to contain weird data, it starts with this:' . PHP_EOL
285		. substr($changes, 0, 200).PHP_EOL.'==================================' . PHP_EOL
286		. 'If the file is ok, please add your conditions to file '
287		. 'res/extensions/t3deploy/classes/class.tx_t3deploy_databaseController.php in t3deploy.'
288		);
289		}
290	3	}
291
292		/**
293		* Removes key modifications that will cause errors.
294		*
295		* @param array $differences The differences to be cleaned up
296		* @return array The cleaned differences
297		*/
298	5	protected function removeKeyModifications(array $differences)
299		{
300	5	$differences = $this->unsetSubKey($differences, 'extra', 'keys', 'whole_table');
301	5	$differences = $this->unsetSubKey($differences, 'diff', 'keys');
302
303	5	return $differences;
304		}
305
306		/**
307		* Unsets a subkey in a given differences array.
308		*
309		* @param array $differences
310		* @param string $type e.g. extra or diff
311		* @param string $subKey e.g. keys or fields
312		* @param string $exception e.g. whole_table that stops the removal
313		* @return array
314		*/
315	5	protected function unsetSubKey(array $differences, $type, $subKey, $exception = '')
316		{
317	5	if (isset($differences[$type])) {
318	5	foreach ($differences[$type] as $table => $information) {
319	5	$isException = ($exception && isset($information[$exception]) && $information[$exception]);
320	5	if (isset($information[$subKey]) && $isException === false) {
321	5	unset($differences[$type][$table][$subKey]);
322		}
323		}
324		}
325
326	5	return $differences;
327		}
328
329		/**
330		* Gets the differences in the database structure by comparing
331		* the current structure with the SQL definitions of all extensions
332		* and the TYPO3 core in t3lib/stddb/tables.sql.
333		*
334		* This method searches for fields/tables to be added/updated.
335		*
336		* @param boolean $allowKeyModifications Whether to allow key modifications
337		* @return array The database statements to update the structure
338		*/
339	5	protected function getStructureDifferencesForUpdate($allowKeyModifications = false)
340		{
341	5	$differences = $this->schemaMigrationService->getDatabaseExtra(
342	5	$this->getDefinedFieldDefinitions(),
343	5	$this->schemaMigrationService->getFieldDefinitions_database()
344		);
345
346	5	if (!$allowKeyModifications) {
347	5	$differences = $this->removeKeyModifications($differences);
348		}
349
350	5	return $differences;
351		}
352
353		/**
354		* Gets the differences in the database structure by comparing
355		* the current structure with the SQL definitions of all extensions
356		* and the TYPO3 core in t3lib/stddb/tables.sql.
357		*
358		* This method searches for fields/tables to be removed.
359		*
360		* @param boolean $allowKeyModifications Whether to allow key modifications
361		* @return array The database statements to update the structure
362		*/
363	2	protected function getStructureDifferencesForRemoval($allowKeyModifications = false)
364		{
365	2	$differences = $this->schemaMigrationService->getDatabaseExtra(
366	2	$this->schemaMigrationService->getFieldDefinitions_database(),
367	2	$this->getDefinedFieldDefinitions()
368		);
369
370	2	if (!$allowKeyModifications) {
371	2	$differences = $this->removeKeyModifications($differences);
372		}
373
374	2	return $differences;
375		}
376
377		/**
378		* Gets the defined field definitions from the ext_tables.sql files.
379		*
380		* @return array The accordant definitions
381		*/
382	5	protected function getDefinedFieldDefinitions()
383		{
384	5	$cacheTables = $this->categoryRegistry->getDatabaseTableDefinitions();
385	5	$content = $this->schemaMigrationService->getFieldDefinitions_fileContent(
386	5	implode(chr(10), $this->getAllRawStructureDefinitions()) . $cacheTables
387		);
388	5	return $content;
389		}
390
391		/**
392		* Gets all structure definitions of extensions the TYPO3 Core.
393		*
394		* @return array All structure definitions
395		*/
396	5	protected function getAllRawStructureDefinitions()
397		{
398
399	5	$expectedSchemaString = $this->expectedSchemaService->getTablesDefinitionString(true);
400	5	$rawDefinitions = $this->schemaMigrationService->getStatementArray($expectedSchemaString, true);
401
402	5	return $rawDefinitions;
403		}
404
405		/**
406		* Gets the defined update types.
407		*
408		* @return array
409		*/
410	5	protected function getUpdateTypes()
411		{
412	5	return \TYPO3\CMS\Core\Utility\GeneralUtility::trimExplode(',', self::UpdateTypes_List, true);
413		}
414
415		/**
416		* Gets the defined remove types.
417		*
418		* @return array
419		*/
420	2	protected function getRemoveTypes()
421		{
422	2	return \TYPO3\CMS\Core\Utility\GeneralUtility::trimExplode(',', self::RemoveTypes_list, true);
423		}
424
425		/**
426		* sorts the statements in an array
427		*
428		* @param array $statements
429		* @return array
430		*/
431	5	protected function sortStatements($statements)
432		{
433	5	$newStatements = [];
434
435	5	foreach($statements as $key=>$statement) {
436	5	if($this->isDropKeyStatement($statement)) {
437	5	$newStatements[$key] = $statement;
438		}
439		}
440
441	5	foreach($statements as $key=>$statement) {
442		// writing the statement again, does not change its position
443		// this saves a condition check
444	5	$newStatements[$key] = $statement;
445		}
446
447	5	return $newStatements;
448		}
449
450		/**
451		* returns true if the given statement looks as if it drops a (primary) key
452		*
453		* @param $statement
454		* @return bool
455		*/
456	5	protected function isDropKeyStatement($statement)
457		{
458	5	return strpos($statement, ' DROP ') !== false && strpos($statement, ' KEY') !== false;
459		}
460		}
461

AOEpeople / t3deploy

GitHub Access Token became invalid

Pull Request — master (#4)

DatabaseController::unsetSubKey() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like