DatabaseController::updateStructureAction() - 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 15:40 UTC

DatabaseController::updateStructureAction() D

↳ Parent: DatabaseController

Complexity

Conditions	9
Paths	32

Size

Total Lines	34
Code Lines	19

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	90

Importance

Changes

Metric	Value
dl	0
loc	34
ccs	0
cts	19
cp	0
rs	4.909
c	0
b	0
f	0
cc	9
eloc	19
nc	32
nop	1
crap	90

<?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()
    {
        $packageStates = include(PATH_typo3conf .'PackageStates.php');

        $tmp = $GLOBALS['TYPO3_LOADED_EXT'];

        $GLOBALS['TYPO3_LOADED_EXT'] = array_merge($packageStates['packages'], $GLOBALS['TYPO3_LOADED_EXT']);

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

        $GLOBALS['TYPO3_LOADED_EXT'] = $tmp;

        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			public function __construct()
74			{
75			/** @var ObjectManager $objectManager */
76			$objectManager = GeneralUtility::makeInstance(ObjectManager::class);
77
78			$this->schemaMigrationService = $objectManager->get(SqlSchemaMigrationService::class);
79			$this->expectedSchemaService = $objectManager->get(SqlExpectedSchemaService::class);
80			$this->categoryRegistry = $objectManager->get(CategoryRegistry::class);
81
82			$this->setConsideredTypes($this->getUpdateTypes());
83			}
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			public function setConsideredTypes(array $consideredTypes)
93			{
94			$this->consideredTypes = $consideredTypes;
95			}
96
97			/**
98			* Adds considered types.
99			*
100			* @param array $consideredTypes
101			* @return void
102			* @see updateStructureAction()
103			*/
104			public function addConsideredTypes(array $consideredTypes)
105			{
106			$this->consideredTypes = array_unique(
107			array_merge($this->consideredTypes, $consideredTypes)
108			);
109			}
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			public function updateStructureAction(array $arguments)
131			{
132			$isExecuteEnabled = (isset($arguments['--execute']) \|\| isset($arguments['-e']));
133			$isRemovalEnabled = (isset($arguments['--remove']) \|\| isset($arguments['-r']));
134			$isModifyKeysEnabled = isset($arguments['--drop-keys']);
135
136			$result = $this->executeUpdateStructureUntilNoMoreChanges($arguments, $isModifyKeysEnabled);
137
138			if(isset($arguments['--dump-file'])) {
139			$dumpFileName = $arguments['--dump-file'][0];
140
141			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			if (file_exists($dumpFileName) && !is_writable($dumpFileName)) {
148			throw new \InvalidArgumentException(sprintf(
149			'file %s is not writable', $dumpFileName
150			));
151			}
152
153			file_put_contents($dumpFileName, $result);
154			$result = sprintf("Output written to %s\n", $dumpFileName);
155			}
156
157			if ($isExecuteEnabled) {
158			$result .= ($result ? PHP_EOL : '')
159			. $this->executeUpdateStructureUntilNoMoreChanges($arguments, $isRemovalEnabled);
160			}
161
162			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			protected function executeUpdateStructureUntilNoMoreChanges(array $arguments, $allowKeyModifications = false)
178			{
179			$result = '';
180			$iteration = 1;
181			$loopResult = '';
182
183			do {
184			$previousLoopResult = $loopResult;
185			$loopResult = $this->executeUpdateStructure($arguments, $allowKeyModifications);
186
187			if ($loopResult == $previousLoopResult) {
188			break;
189			}
190
191			$result .= sprintf("\n# Iteration %d\n%s", $iteration++, $loopResult);
192
193			if ($iteration > 10) {
194			$result .= "\nGiving up after 10 iterations.";
195			break;
196			}
197			} while (!empty($loopResult));
198
199			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			protected function executeUpdateStructure(array $arguments, $allowKeyModifications = false)
211			{
212			$result = '';
213
214			$isExecuteEnabled = (isset($arguments['--execute']) \|\| isset($arguments['-e']));
215			$isRemovalEnabled = (isset($arguments['--remove']) \|\| isset($arguments['-r']));
216			$isVerboseEnabled = (isset($arguments['--verbose']) \|\| isset($arguments['-v']));
217			$hasExcludes = (isset($arguments['--excludes']) && is_array($arguments['--excludes']));
218
219			$changes = $this->schemaMigrationService->getUpdateSuggestions(
220			$this->getStructureDifferencesForUpdate($allowKeyModifications)
221			);
222
223			if ($isRemovalEnabled) {
224			// Disable the delete prefix, thus tables and fields can be removed directly:
225			$this->schemaMigrationService->setDeletedPrefixKey('');
226
227			// Add types considered for removal:
228			$this->addConsideredTypes($this->getRemoveTypes());
229			// Merge update suggestions:
230			$removals = $this->schemaMigrationService->getUpdateSuggestions(
231			$this->getStructureDifferencesForRemoval($allowKeyModifications),
232			'remove'
233			);
234			$changes = array_merge($changes, $removals);
235			}
236
237			if ($hasExcludes) {
238			$excludes = explode(',', $arguments['--excludes'][0]);
239			$this->removeConsideredTypes($excludes);
240			}
241
242			if ($isExecuteEnabled \|\| $isVerboseEnabled) {
243			$statements = [];
244
245			// Concatenates all statements:
246			foreach ($this->consideredTypes as $consideredType) {
247			if (isset($changes[$consideredType]) && is_array($changes[$consideredType])) {
248			$statements += $changes[$consideredType];
249			}
250			}
251
252			$statements = $this->sortStatements($statements);
253
254			if ($isExecuteEnabled) {
255			foreach ($statements as $statement) {
256			$GLOBALS['TYPO3_DB']->admin_query($statement);
257			}
258			}
259
260			if ($isVerboseEnabled) {
261			$result = implode(PHP_EOL, $statements);
262			}
263			}
264
265			$this->checkChangesSyntax($result);
266
267			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			protected function checkChangesSyntax($changes)
277			{
278			if (strlen($changes) < 10) return;
279
280			$checked = substr(ltrim($changes), 0, 10);
281
282			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			}
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			protected function removeKeyModifications(array $differences)
299			{
300			$differences = $this->unsetSubKey($differences, 'extra', 'keys', 'whole_table');
301			$differences = $this->unsetSubKey($differences, 'diff', 'keys');
302
303			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			protected function unsetSubKey(array $differences, $type, $subKey, $exception = '')
316			{
317			if (isset($differences[$type])) {
318			foreach ($differences[$type] as $table => $information) {
319			$isException = ($exception && isset($information[$exception]) && $information[$exception]);
320			if (isset($information[$subKey]) && $isException === false) {
321			unset($differences[$type][$table][$subKey]);
322			}
323			}
324			}
325
326			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			protected function getStructureDifferencesForUpdate($allowKeyModifications = false)
340			{
341			$differences = $this->schemaMigrationService->getDatabaseExtra(
342			$this->getDefinedFieldDefinitions(),
343			$this->schemaMigrationService->getFieldDefinitions_database()
344			);
345
346			if (!$allowKeyModifications) {
347			$differences = $this->removeKeyModifications($differences);
348			}
349
350			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			protected function getStructureDifferencesForRemoval($allowKeyModifications = false)
364			{
365			$differences = $this->schemaMigrationService->getDatabaseExtra(
366			$this->schemaMigrationService->getFieldDefinitions_database(),
367			$this->getDefinedFieldDefinitions()
368			);
369
370			if (!$allowKeyModifications) {
371			$differences = $this->removeKeyModifications($differences);
372			}
373
374			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			protected function getDefinedFieldDefinitions()
383			{
384			$cacheTables = $this->categoryRegistry->getDatabaseTableDefinitions();
385			$content = $this->schemaMigrationService->getFieldDefinitions_fileContent(
386			implode(chr(10), $this->getAllRawStructureDefinitions()) . $cacheTables
387			);
388			return $content;
389			}
390
391			/**
392			* Gets all structure definitions of extensions the TYPO3 Core.
393			*
394			* @return array All structure definitions
395			*/
396			protected function getAllRawStructureDefinitions()
397			{
398			$packageStates = include(PATH_typo3conf .'PackageStates.php');
399
400			$tmp = $GLOBALS['TYPO3_LOADED_EXT'];
401
402			$GLOBALS['TYPO3_LOADED_EXT'] = array_merge($packageStates['packages'], $GLOBALS['TYPO3_LOADED_EXT']);
403
404			$expectedSchemaString = $this->expectedSchemaService->getTablesDefinitionString(true);
405			$rawDefinitions = $this->schemaMigrationService->getStatementArray($expectedSchemaString, true);
406
407			$GLOBALS['TYPO3_LOADED_EXT'] = $tmp;
408
409			return $rawDefinitions;
410			}
411
412			/**
413			* Gets the defined update types.
414			*
415			* @return array
416			*/
417			protected function getUpdateTypes()
418			{
419			return \TYPO3\CMS\Core\Utility\GeneralUtility::trimExplode(',', self::UpdateTypes_List, true);
420			}
421
422			/**
423			* Gets the defined remove types.
424			*
425			* @return array
426			*/
427			protected function getRemoveTypes()
428			{
429			return \TYPO3\CMS\Core\Utility\GeneralUtility::trimExplode(',', self::RemoveTypes_list, true);
430			}
431
432			/**
433			* sorts the statements in an array
434			*
435			* @param array $statements
436			* @return array
437			*/
438			protected function sortStatements($statements)
439			{
440			$newStatements = [];
441
442			foreach($statements as $key=>$statement) {
443			if($this->isDropKeyStatement($statement)) {
444			$newStatements[$key] = $statement;
445			}
446			}
447
448			foreach($statements as $key=>$statement) {
449			// writing the statement again, does not change its position
450			// this saves a condition check
451			$newStatements[$key] = $statement;
452			}
453
454			return $newStatements;
455			}
456
457			/**
458			* returns true if the given statement looks as if it drops a (primary) key
459			*
460			* @param $statement
461			* @return bool
462			*/
463			protected function isDropKeyStatement($statement)
464			{
465			return strpos($statement, ' DROP ') !== false && strpos($statement, ' KEY') !== false;
466			}
467			}
468

AOEpeople / t3deploy

GitHub Access Token became invalid

Pull Request — master (#4)

DatabaseController::updateStructureAction() D

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like