CreateTable::diffForeigns() - Code Metrics - Inspection of "Implement foreign keys" - graze/morphism - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#61)

by Brendan

created 2019-07-27 08:55 UTC

CreateTable::diffForeigns() B

↳ Parent: Project

Complexity

Conditions	7
Paths	9

Size

Total Lines	21
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	14.9539

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	7
eloc	10
c	1
b	0
f	0
nc	9
nop	1
dl	0
loc	21
rs	8.8333
ccs	5
cts	11
cp	0.4545
crap	14.9539

<?php
namespace Graze\Morphism\Parse;

use RuntimeException;

/**
 * Represents a table definition.
 */
class CreateTable
{
    /** @var string */
    private $name = '';

    /** @var ColumnDefinition[] */
    public $columns = [];

    /** @var IndexDefinition[] definitions of non-foreign keys */
    public $indexes = [];

    /** @var IndexDefinition[] definitions of foreign keys */
    public $foreigns = [];

    /** @var TableOptions */
    public $options = null;

    /** @var array */
    private $covers = [];

    /**
     * Constructor.
     *
     * @param CollationInfo $databaseCollation
     */
    public function __construct(CollationInfo $databaseCollation)
    {
        $this->options = new TableOptions($databaseCollation);
    }

    /**
     * @return string
     */
    public function getName()
    {
        return $this->name;
    }

    /**
     * Sets the storage engine the table is assumed to use, unless
     * explicitly overridden via an ENGINE= clause at the end of
     * the table definition.
     *
     * @param string $engine
     * @return void
     */
    public function setDefaultEngine($engine)
    {
        $this->options->setDefaultEngine($engine);
    }

    /**
     * Parses a table definition from $stream.
     *
     * The DDL may be of the form 'CREATE TABLE ...' or 'CREATE TABLE IF NOT EXISTS ...'.
     *
     * An exception will be thrown if a valid CREATE TABLE statement cannot be recognised.
     *
     * @param TokenStream $stream
     */
    public function parse(TokenStream $stream)
    {
        if ($stream->consume('CREATE TABLE')) {
            $stream->consume('IF NOT EXISTS');
        } else {
            throw new RuntimeException("Expected CREATE TABLE");
        }

        $this->name = $stream->expectName();
        $stream->expectOpenParen();

        while (true) {
            $hasConstraintKeyword = $stream->consume('CONSTRAINT');
            if ($stream->consume('PRIMARY KEY')) {
                $this->parseIndex($stream, 'PRIMARY KEY');
            } elseif ($stream->consume('KEY') ||
                $stream->consume('INDEX')
            ) {
                if ($hasConstraintKeyword) {
                    throw new RuntimeException("Bad CONSTRAINT");
                }
                $this->parseIndex($stream, 'KEY');
            } elseif ($stream->consume('FULLTEXT')) {
                if ($hasConstraintKeyword) {
                    throw new RuntimeException("Bad CONSTRAINT");
                }
                $stream->consume('KEY') || $stream->consume('INDEX');
                $this->parseIndex($stream, 'FULLTEXT KEY');
            } elseif ($stream->consume('UNIQUE')) {
                $stream->consume('KEY') || $stream->consume('INDEX');
                $this->parseIndex($stream, 'UNIQUE KEY');
            } elseif ($stream->consume('FOREIGN KEY')) {
                $this->parseIndex($stream, 'FOREIGN KEY');
            } elseif ($hasConstraintKeyword) {
                $constraint = $stream->expectName();
                if ($stream->consume('PRIMARY KEY')) {
                    $this->parseIndex($stream, 'PRIMARY KEY', $constraint);
                } elseif ($stream->consume('UNIQUE')) {
                    $stream->consume('KEY') || $stream->consume('INDEX');
                    $this->parseIndex($stream, 'UNIQUE KEY', $constraint);
                } elseif ($stream->consume('FOREIGN KEY')) {
                    $this->parseIndex($stream, 'FOREIGN KEY', $constraint);
                } else {
                    throw new RuntimeException("Bad CONSTRAINT");
                }
            } else {
                $this->parseColumn($stream);
            }
            $token = $stream->nextToken();
            if ($token->eq(Token::SYMBOL, ',')) {
                continue;
            } elseif ($token->eq(Token::SYMBOL, ')')) {
                break;
            } else {
                throw new RuntimeException("Expected ',' or ')'");
            }
        }

        $this->processTimestamps();
        $this->processIndexes();
        $this->processAutoIncrement();
        $this->parseTableOptions($stream);
        $this->processColumnCollations();
    }

    /**
     * Returns the table's collation.
     *
     * @return CollationInfo
     */
    public function getCollation()
    {
        return $this->options->collation;
    }

    /**
     * Returns an array of SQL DDL statements to create the table.
     *
     * @return array
     */
    public function getDDL()
    {
        $lines = [];
        foreach ($this->columns as $column) {
            $lines[] = "  " . $column->toString($this->getCollation());
        }
        foreach ($this->indexes as $index) {
            $lines[] = "  " . $index->toString();
        }
        foreach ($this->foreigns as $foreign) {
            $lines[] = "  " . $foreign->toString();
        }

        $text = "CREATE TABLE " . Token::escapeIdentifier($this->name) . " (\n" .
            implode(",\n", $lines) .
            "\n" .
            ")";

        $options = $this->options->toString();
        if ($options !== '') {
            $text .= " " . $this->options->toString();
        }

        return [$text];
    }

    /**
     * @param TokenStream $stream
     */
    private function parseColumn(TokenStream $stream)
    {
        $column = new ColumnDefinition();
        $column->parse($stream);
        if (array_key_exists(strtolower($column->name), $this->columns)) {
            throw new RuntimeException("Duplicate column name '" . $column->name . "'");
        }
        $this->columns[strtolower($column->name)] = $column;
        $this->indexes = array_merge(
            $this->indexes,
            $column->indexes
        );
    }

    /**
     * @param TokenStream $stream
     * @param string $type
     * @param string|null $constraint
     */
    private function parseIndex(TokenStream $stream, $type, $constraint = null)
    {
        $index = new IndexDefinition();
        $index->parse($stream, $type, $constraint);
        $this->indexes[] = $index;
    }

    /**
     * @param TokenStream $stream
     */
    private function parseTableOptions(TokenStream $stream)
    {
        $this->options->parse($stream);
    }

    private function processTimestamps()
    {
        // To specify automatic properties, use the DEFAULT CURRENT_TIMESTAMP
        // and ON UPDATE CURRENT_TIMESTAMP clauses. The order of the clauses
        // does not matter. If both are present in a column definition, either
        // can occur first.

        // collect all timestamps
        $ts = [];
        foreach ($this->columns as $column) {
            if ($column->type === 'timestamp') {
                $ts[] = $column;
            }
        }
        if (count($ts) === 0) {
            return;
        }

        // none of NULL, DEFAULT or ON UPDATE CURRENT_TIMESTAMP have been specified
        if (!$ts[0]->nullable && is_null($ts[0]->default) && !$ts[0]->onUpdateCurrentTimestamp) {
            $ts[0]->nullable = false;
            $ts[0]->default = 'CURRENT_TIMESTAMP';
            $ts[0]->onUpdateCurrentTimestamp = true;
        }

        // [[ this restriction no longer exists as of MySQL 5.6.5 and MariaDB 10.0.1 ]]

        // One TIMESTAMP column in a table can have the current timestamp as
        // the default value for initializing the column, as the auto-update
        // value, or both. It is not possible to have the current timestamp
        // be the default value for one column and the auto-update value for
        // another column.

        // $specials = 0;
        // foreach($ts as $column) {
        //     if ($column->default === 'CURRENT_TIMESTAMP' ||
        //         $column->onUpdateCurrentTimestamp
        //     ) {
        //         if (++$specials > 1) {
        //             throw new RuntimeException("There can be only one TIMESTAMP column with CURRENT_TIMESTAMP in DEFAULT or ON UPDATE clause");
        //         }
        //     }
        // }

        foreach ($ts as $column) {
            if (!$column->nullable && is_null($column->default)) {
                $column->default = '0000-00-00 00:00:00';
            }
        }
    }

    private function processIndexes()
    {
        // check indexes are sane wrt available columns
        foreach ($this->indexes as $index) {
            foreach ($index->columns as $indexColumn) {
                $indexColumnName = $indexColumn['name'];
                if (!array_key_exists(strtolower($indexColumnName), $this->columns)) {
                    throw new RuntimeException("Key column '$indexColumnName' doesn't exist in table");
                }
            }
        }

        // figure out all sequences of columns covered by non-FK indexes
        foreach ($this->indexes as $index) {
            if ($index->type !== 'FOREIGN KEY') {
                foreach ($index->getCovers() as $cover) {
                    $lookup = implode('\0', $cover);
                    $this->covers[$lookup] = true;
                }
            }
        }

        $indexes = [];
        $foreigns = [];
        $ibfkCounter = 0;

        foreach ($this->indexes as $index) {
            if ($index->type === 'FOREIGN KEY') {
                // TODO - doesn't correctly deal with indexes like foo(10)
                $lookup = implode('\0', $index->getColumns());
                if (!array_key_exists($lookup, $this->covers)) {
                    $newIndex = new IndexDefinition();
                    $newIndex->type = 'KEY';
                    $newIndex->columns = $index->columns;
                    if (!is_null($index->constraint)) {
                        $newIndex->name = $index->constraint;
                    } elseif (!is_null($index->name)) {
                        $newIndex->name = $index->name;
                    }
                    $indexes[] = $newIndex;
                }
                $foreign = new IndexDefinition();
                if (is_null($index->constraint)) {
                    $foreign->constraint = $this->name . '_ibfk_' . ++$ibfkCounter;
                } else {
                    $foreign->constraint = $index->constraint;
                }
                $foreign->type = 'FOREIGN KEY';
                $foreign->columns = $index->columns;
                $foreign->reference = $index->reference;
                $foreigns[] = $foreign;
            } else {
                $indexes[] = $index;
            }
        }

        // now synthesise names for any unnamed indexes,
        // and collect indexes by type
        $usedName = [];
        $keyTypes = [
            'PRIMARY KEY',
            'UNIQUE KEY',
            'KEY',
            'FULLTEXT KEY',
            'FOREIGN KEY',
        ];
        $indexesByType = array_fill_keys($keyTypes, []);
        foreach ($indexes as $index) {
            $name = $index->name;
            if ($index->type === 'PRIMARY KEY') {
                $name = 'PRIMARY';
            } elseif (is_null($name)) {
                $base = $index->columns[0]['name'];
                $name = $base;
                $i = 1;
                while (isset($usedName[$name])) {
                    $name = $base . '_' . ++$i;
                }
                $index->name = $name;
            } elseif (array_key_exists(strtolower($name), $usedName)) {
                throw new RuntimeException("Duplicate key name '$name'");
            }
            $index->name = $name;
            $usedName[strtolower($name)] = true;

            $indexesByType[$index->type][] = $index;
        }

        if (count($indexesByType['PRIMARY KEY']) > 1) {
            throw new RuntimeException("Multiple PRIMARY KEYs defined");
        }

        foreach ($indexesByType['PRIMARY KEY'] as $pk) {
            foreach ($pk->columns as $indexColumn) {
                $column = $this->columns[strtolower($indexColumn['name'])];
                if ($column->nullable) {
                    $column->nullable = false;
                    if (is_null($column->default)) {
                        $column->default = $column->getUninitialisedValue();
                    }
                }
            }
        }

        $this->indexes = [];
        foreach (array_reduce($indexesByType, 'array_merge', []) as $index) {
            $this->indexes[$index->name] = $index;
        }
        foreach ($foreigns as $foreign) {
            $this->foreigns[$foreign->constraint] = $foreign;
        }
    }

    private function processAutoIncrement()
    {
        $count = 0;
        foreach ($this->columns as $column) {
            if ($column->autoIncrement) {
                if (++$count > 1) {
                    throw new RuntimeException("There can be only one AUTO_INCREMENT column");
                }
                if (! array_key_exists($column->name, $this->covers)) {
                    throw new RuntimeException("AUTO_INCREMENT column must be defined as a key");
                }
            }
        }
    }

    private function processColumnCollations()
    {
        foreach ($this->columns as $column) {
            $column->applyTableCollation($this->getCollation());
        }
    }

    /**
     * Returns ALTER TABLE statement to transform this table into the one
     * represented by $that. If the tables are already equivalent, just
     * returns the empty string.
     *
     * $flags        |
     * :-------------|----
     * 'alterEngine' | (bool) include ALTER TABLE ... ENGINE= [default: true]
     *
     * @param CreateTable $that
     * @param array $flags
     * @return string[]
     */
    public function diff(CreateTable $that, array $flags = [])
    {
        $flags += [
            'alterEngine' => true
        ];

        $alters = array_merge(
            $this->diffColumns($that),
            $this->diffIndexes($that),
            $this->diffForeigns($that),
            $this->diffOptions($that, [
                'alterEngine' => $flags['alterEngine']
            ])
        );

        if (count($alters) === 0) {
            return [];
        }

        return ["ALTER TABLE " . Token::escapeIdentifier($this->name) . "\n" . implode(",\n", $alters)];
    }

    /**
     * @param CreateTable $that
     * @return array
     */
    private function diffColumns(CreateTable $that)
    {
        $alters = [];
        $permutation = [];
        foreach (array_keys($this->columns) as $columnName) {
            if (array_key_exists($columnName, $that->columns)) {
                $permutation[] = $columnName;
            } else {
                $alters[] = "DROP COLUMN " . Token::escapeIdentifier($columnName);
            }
        }

        $prevColumn = null;
        $thatPosition = " FIRST";
        $j = 0;
        foreach ($that->columns as $columnName => $column) {
            if (array_key_exists($columnName, $this->columns)) {
                // An existing column is being changed
                $thisDefinition = $this->columns[$columnName]->toString($this->getCollation());
                $thatDefinition = $that->columns[$columnName]->toString($that->getCollation());

                // about to 'add' $columnName - get its location in the currently
                // permuted state of the tabledef
                $i = array_search($columnName, $permutation);

                // figure out the column it currently sits after, in case we
                // need to change it
                $thisPosition = ($i === 0) ? " FIRST" : " AFTER " . Token::escapeIdentifier($permutation[$i - 1]);

                if ($thisDefinition !== $thatDefinition ||
                    $thisPosition   !== $thatPosition
                ) {
                    $alter = "MODIFY COLUMN " . $thatDefinition;

                    // position has changed
                    if ($thisPosition !== $thatPosition) {
                        $alter .= $thatPosition;

                        // We need to update our permutation to reflect the new position.
                        // Column is being inserted at position $j, and is currently residing at $i.

                        // remove from current location
                        array_splice($permutation, /** @scrutinizer ignore-type */ $i, 1, []);

                        // insert at new location
                        array_splice($permutation, $j, 0, $columnName);
                    }

                    $alters[] = $alter;
                }
            } else {
                // A new column is being added
                $alter = "ADD COLUMN " . $column->toString($this->getCollation());
                if ($j < count($permutation)) {
                    $alter .= $thatPosition;
                }
                $alters[] = $alter;

                $i = is_null($prevColumn) ? 0 : 1 + array_search($prevColumn, $permutation);
                array_splice($permutation, $i, 0, [$columnName]);
            }

            $prevColumn = $columnName;
            $thatPosition = " AFTER " . Token::escapeIdentifier($prevColumn);
            $j++;
        }

        return $alters;
    }

    /**
     * @param CreateTable $that
     * @return array
     */
    private function diffIndexes(CreateTable $that)
    {
        $alters = [];

        foreach ($this->indexes as $indexName => $index) {
            if (!array_key_exists($indexName, $that->indexes) ||
                $index->toString() !== $that->indexes[$indexName]->toString()
            ) {
                switch ($index->type) {
                    case 'PRIMARY KEY':
                        $alter = "DROP PRIMARY KEY";
                        break;

                    default:
                        $alter = "DROP KEY " . Token::escapeIdentifier($indexName);
                        break;
                }
                $alters[] = $alter;
            }
        }

        foreach ($that->indexes as $indexName => $index) {
            if (!array_key_exists($indexName, $this->indexes) ||
                $index->toString() !== $this->indexes[$indexName]->toString()
            ) {
                $alters[] = "ADD " . $index->toString();
            }
        }

        return $alters;
    }

    /**
     * @param CreateTable $that
     * @return array
     */
    private function diffForeigns(CreateTable $that)
    {
        $alters = [];

        foreach ($this->foreigns as $foreignName => $foreign) {
            if (!array_key_exists($foreignName, $that->foreigns) ||
                $foreign->toString() !== $that->foreigns[$foreignName]->toString()
            ) {
                $alters[] = "DROP FOREIGN KEY " . Token::escapeIdentifier($foreignName);
            }
        }

        foreach ($that->foreigns as $foreignName => $foreign) {
            if (!array_key_exists($foreignName, $this->foreigns) ||
                $foreign->toString() !== $this->foreigns[$foreignName]->toString()
            ) {
                $alters[] = "ADD " . $foreign->toString();
            }
        }

        return $alters;
    }

    /**
     * @param CreateTable $that
     * @param array $flags
     * @return array
     */
    private function diffOptions(CreateTable $that, array $flags = [])
    {
        $flags += [
            'alterEngine' => true
        ];
        $diff = $this->options->diff($that->options, [
            'alterEngine' => $flags['alterEngine']
        ]);
        return ($diff == '') ? [] : [$diff];
    }
}


1		<?php
2		namespace Graze\Morphism\Parse;
3
4		use RuntimeException;
5
6		/**
7		* Represents a table definition.
8		*/
9		class CreateTable
10		{
11		/** @var string */
12		private $name = '';
13
14		/** @var ColumnDefinition[] */
15		public $columns = [];
16
17		/** @var IndexDefinition[] definitions of non-foreign keys */
18		public $indexes = [];
19
20		/** @var IndexDefinition[] definitions of foreign keys */
21		public $foreigns = [];
22
23		/** @var TableOptions */
24		public $options = null;
25
26		/** @var array */
27		private $covers = [];
28
29		/**
30		* Constructor.
31		*
32		* @param CollationInfo $databaseCollation
33		*/
34	93	public function __construct(CollationInfo $databaseCollation)
35		{
36	93	$this->options = new TableOptions($databaseCollation);
37	93	}
38
39		/**
40		* @return string
41		*/
42	1	public function getName()
43		{
44	1	return $this->name;
45		}
46
47		/**
48		* Sets the storage engine the table is assumed to use, unless
49		* explicitly overridden via an ENGINE= clause at the end of
50		* the table definition.
51		*
52		* @param string $engine
53		* @return void
54		*/
55	91	public function setDefaultEngine($engine)
56		{
57	91	$this->options->setDefaultEngine($engine);
58	91	}
59
60		/**
61		* Parses a table definition from $stream.
62		*
63		* The DDL may be of the form 'CREATE TABLE ...' or 'CREATE TABLE IF NOT EXISTS ...'.
64		*
65		* An exception will be thrown if a valid CREATE TABLE statement cannot be recognised.
66		*
67		* @param TokenStream $stream
68		*/
69	90	public function parse(TokenStream $stream)
70		{
71	90	if ($stream->consume('CREATE TABLE')) {
72	89	$stream->consume('IF NOT EXISTS');
73		} else {
74	1	throw new RuntimeException("Expected CREATE TABLE");
75		}
76
77	89	$this->name = $stream->expectName();
78	89	$stream->expectOpenParen();
79
80	89	while (true) {
81	89	$hasConstraintKeyword = $stream->consume('CONSTRAINT');
82	89	if ($stream->consume('PRIMARY KEY')) {
83	10	$this->parseIndex($stream, 'PRIMARY KEY');
84	89	} elseif ($stream->consume('KEY') \|\|
85	89	$stream->consume('INDEX')
86		) {
87	18	if ($hasConstraintKeyword) {
88	2	throw new RuntimeException("Bad CONSTRAINT");
89		}
90	16	$this->parseIndex($stream, 'KEY');
91	89	} elseif ($stream->consume('FULLTEXT')) {
92	4	if ($hasConstraintKeyword) {
93	1	throw new RuntimeException("Bad CONSTRAINT");
94		}
95	3	$stream->consume('KEY') \|\| $stream->consume('INDEX');
96	3	$this->parseIndex($stream, 'FULLTEXT KEY');
97	89	} elseif ($stream->consume('UNIQUE')) {
98	5	$stream->consume('KEY') \|\| $stream->consume('INDEX');
99	5	$this->parseIndex($stream, 'UNIQUE KEY');
100	89	} elseif ($stream->consume('FOREIGN KEY')) {
101	8	$this->parseIndex($stream, 'FOREIGN KEY');
102	89	} elseif ($hasConstraintKeyword) {
103	4	$constraint = $stream->expectName();
104	4	if ($stream->consume('PRIMARY KEY')) {
105	1	$this->parseIndex($stream, 'PRIMARY KEY', $constraint);
106	3	} elseif ($stream->consume('UNIQUE')) {
107	1	$stream->consume('KEY') \|\| $stream->consume('INDEX');
108	1	$this->parseIndex($stream, 'UNIQUE KEY', $constraint);
109	2	} elseif ($stream->consume('FOREIGN KEY')) {
110	1	$this->parseIndex($stream, 'FOREIGN KEY', $constraint);
111		} else {
112	4	throw new RuntimeException("Bad CONSTRAINT");
113		}
114		} else {
115	89	$this->parseColumn($stream);
116		}
117	86	$token = $stream->nextToken();
118	86	if ($token->eq(Token::SYMBOL, ',')) {
119	61	continue;
120	80	} elseif ($token->eq(Token::SYMBOL, ')')) {
121	79	break;
122		} else {
123	1	throw new RuntimeException("Expected ',' or ')'");
124		}
125		}
126
127	79	$this->processTimestamps();
128	79	$this->processIndexes();
129	75	$this->processAutoIncrement();
130	73	$this->parseTableOptions($stream);
131	73	$this->processColumnCollations();
132	73	}
133
134		/**
135		* Returns the table's collation.
136		*
137		* @return CollationInfo
138		*/
139	73	public function getCollation()
140		{
141	73	return $this->options->collation;
142		}
143
144		/**
145		* Returns an array of SQL DDL statements to create the table.
146		*
147		* @return array
148		*/
149	53	public function getDDL()
150		{
151	53	$lines = [];
152	53	foreach ($this->columns as $column) {
153	53	$lines[] = " " . $column->toString($this->getCollation());
154		}
155	53	foreach ($this->indexes as $index) {
156	35	$lines[] = " " . $index->toString();
157		}
158	53	foreach ($this->foreigns as $foreign) {
159	9	$lines[] = " " . $foreign->toString();
160		}
161
162	53	$text = "CREATE TABLE " . Token::escapeIdentifier($this->name) . " (\n" .
163	53	implode(",\n", $lines) .
164	53	"\n" .
165	53	")";
166
167	53	$options = $this->options->toString();
168	53	if ($options !== '') {
169	53	$text .= " " . $this->options->toString();
170		}
171
172	53	return [$text];
173		}
174
175		/**
176		* @param TokenStream $stream
177		*/
178	89	private function parseColumn(TokenStream $stream)
179		{
180	89	$column = new ColumnDefinition();
181	89	$column->parse($stream);
182	86	if (array_key_exists(strtolower($column->name), $this->columns)) {
183	2	throw new RuntimeException("Duplicate column name '" . $column->name . "'");
184		}
185	86	$this->columns[strtolower($column->name)] = $column;
186	86	$this->indexes = array_merge(
187	86	$this->indexes,
188	86	$column->indexes
189		);
190	86	}
191
192		/**
193		* @param TokenStream $stream
194		* @param string $type
195		* @param string\|null $constraint
196		*/
197	38	private function parseIndex(TokenStream $stream, $type, $constraint = null)
198		{
199	38	$index = new IndexDefinition();
200	38	$index->parse($stream, $type, $constraint);
201	38	$this->indexes[] = $index;
202	38	}
203
204		/**
205		* @param TokenStream $stream
206		*/
207	73	private function parseTableOptions(TokenStream $stream)
208		{
209	73	$this->options->parse($stream);
210	73	}
211
212	79	private function processTimestamps()
213		{
214		// To specify automatic properties, use the DEFAULT CURRENT_TIMESTAMP
215		// and ON UPDATE CURRENT_TIMESTAMP clauses. The order of the clauses
216		// does not matter. If both are present in a column definition, either
217		// can occur first.
218
219		// collect all timestamps
220	79	$ts = [];
221	79	foreach ($this->columns as $column) {
222	79	if ($column->type === 'timestamp') {
223	12	$ts[] = $column;
224		}
225		}
226	79	if (count($ts) === 0) {
227	67	return;
228		}
229
230		// none of NULL, DEFAULT or ON UPDATE CURRENT_TIMESTAMP have been specified
231	12	if (!$ts[0]->nullable && is_null($ts[0]->default) && !$ts[0]->onUpdateCurrentTimestamp) {
232	3	$ts[0]->nullable = false;
233	3	$ts[0]->default = 'CURRENT_TIMESTAMP';
234	3	$ts[0]->onUpdateCurrentTimestamp = true;
235		}
236
237		// [[ this restriction no longer exists as of MySQL 5.6.5 and MariaDB 10.0.1 ]]
238
239		// One TIMESTAMP column in a table can have the current timestamp as
240		// the default value for initializing the column, as the auto-update
241		// value, or both. It is not possible to have the current timestamp
242		// be the default value for one column and the auto-update value for
243		// another column.
244
245		// $specials = 0;
246		// foreach($ts as $column) {
247		// if ($column->default === 'CURRENT_TIMESTAMP' \|\|
248		// $column->onUpdateCurrentTimestamp
249		// ) {
250		// if (++$specials > 1) {
251		// throw new RuntimeException("There can be only one TIMESTAMP column with CURRENT_TIMESTAMP in DEFAULT or ON UPDATE clause");
252		// }
253		// }
254		// }
255
256	12	foreach ($ts as $column) {
257	12	if (!$column->nullable && is_null($column->default)) {
258	4	$column->default = '0000-00-00 00:00:00';
259		}
260		}
261	12	}
262
263	79	private function processIndexes()
264		{
265		// check indexes are sane wrt available columns
266	79	foreach ($this->indexes as $index) {
267	46	foreach ($index->columns as $indexColumn) {
268	46	$indexColumnName = $indexColumn['name'];
269	46	if (!array_key_exists(strtolower($indexColumnName), $this->columns)) {
270	1	throw new RuntimeException("Key column '$indexColumnName' doesn't exist in table");
271		}
272		}
273		}
274
275		// figure out all sequences of columns covered by non-FK indexes
276	78	foreach ($this->indexes as $index) {
277	45	if ($index->type !== 'FOREIGN KEY') {
278	41	foreach ($index->getCovers() as $cover) {
279	41	$lookup = implode('\0', $cover);
280	41	$this->covers[$lookup] = true;
281		}
282		}
283		}
284
285	78	$indexes = [];
286	78	$foreigns = [];
287	78	$ibfkCounter = 0;
288
289	78	foreach ($this->indexes as $index) {
290	45	if ($index->type === 'FOREIGN KEY') {
291		// TODO - doesn't correctly deal with indexes like foo(10)
292	9	$lookup = implode('\0', $index->getColumns());
293	9	if (!array_key_exists($lookup, $this->covers)) {
294	7	$newIndex = new IndexDefinition();
295	7	$newIndex->type = 'KEY';
296	7	$newIndex->columns = $index->columns;
297	7	if (!is_null($index->constraint)) {
298	1	$newIndex->name = $index->constraint;
299	6	} elseif (!is_null($index->name)) {
300	1	$newIndex->name = $index->name;
301		}
302	7	$indexes[] = $newIndex;
303		}
304	9	$foreign = new IndexDefinition();
305	9	if (is_null($index->constraint)) {
306	8	$foreign->constraint = $this->name . '_ibfk_' . ++$ibfkCounter;
307		} else {
308	1	$foreign->constraint = $index->constraint;
309		}
310	9	$foreign->type = 'FOREIGN KEY';
311	9	$foreign->columns = $index->columns;
312	9	$foreign->reference = $index->reference;
313	9	$foreigns[] = $foreign;
314		} else {
315	41	$indexes[] = $index;
316		}
317		}
318
319		// now synthesise names for any unnamed indexes,
320		// and collect indexes by type
321	78	$usedName = [];
322		$keyTypes = [
323	78	'PRIMARY KEY',
324		'UNIQUE KEY',
325		'KEY',
326		'FULLTEXT KEY',
327		'FOREIGN KEY',
328		];
329	78	$indexesByType = array_fill_keys($keyTypes, []);
330	78	foreach ($indexes as $index) {
331	45	$name = $index->name;
332	45	if ($index->type === 'PRIMARY KEY') {
333	19	$name = 'PRIMARY';
334	27	} elseif (is_null($name)) {
335	16	$base = $index->columns[0]['name'];
336	16	$name = $base;
337	16	$i = 1;
338	16	while (isset($usedName[$name])) {
339	1	$name = $base . '_' . ++$i;
340		}
341	16	$index->name = $name;
342	14	} elseif (array_key_exists(strtolower($name), $usedName)) {
343	2	throw new RuntimeException("Duplicate key name '$name'");
344		}
345	45	$index->name = $name;
346	45	$usedName[strtolower($name)] = true;
347
348	45	$indexesByType[$index->type][] = $index;
349		}
350
351	76	if (count($indexesByType['PRIMARY KEY']) > 1) {
352	1	throw new RuntimeException("Multiple PRIMARY KEYs defined");
353		}
354
355	75	foreach ($indexesByType['PRIMARY KEY'] as $pk) {
356	18	foreach ($pk->columns as $indexColumn) {
357	18	$column = $this->columns[strtolower($indexColumn['name'])];
358	18	if ($column->nullable) {
359	10	$column->nullable = false;
360	10	if (is_null($column->default)) {
361	10	$column->default = $column->getUninitialisedValue();
362		}
363		}
364		}
365		}
366
367	75	$this->indexes = [];
368	75	foreach (array_reduce($indexesByType, 'array_merge', []) as $index) {
369	42	$this->indexes[$index->name] = $index;
370		}
371	75	foreach ($foreigns as $foreign) {
372	9	$this->foreigns[$foreign->constraint] = $foreign;
373		}
374	75	}
375
376	75	private function processAutoIncrement()
377		{
378	75	$count = 0;
379	75	foreach ($this->columns as $column) {
380	75	if ($column->autoIncrement) {
381	3	if (++$count > 1) {
382	1	throw new RuntimeException("There can be only one AUTO_INCREMENT column");
383		}
384	3	if (! array_key_exists($column->name, $this->covers)) {
385	1	throw new RuntimeException("AUTO_INCREMENT column must be defined as a key");
386		}
387		}
388		}
389	73	}
390
391	73	private function processColumnCollations()
392		{
393	73	foreach ($this->columns as $column) {
394	73	$column->applyTableCollation($this->getCollation());
395		}
396	73	}
397
398		/**
399		* Returns ALTER TABLE statement to transform this table into the one
400		* represented by $that. If the tables are already equivalent, just
401		* returns the empty string.
402		*
403		* $flags \|
404		* :-------------\|----
405		* 'alterEngine' \| (bool) include ALTER TABLE ... ENGINE= [default: true]
406		*
407		* @param CreateTable $that
408		* @param array $flags
409		* @return string[]
410		*/
411	20	public function diff(CreateTable $that, array $flags = [])
412		{
413		$flags += [
414	20	'alterEngine' => true
415		];
416
417	20	$alters = array_merge(
418	20	$this->diffColumns($that),
419	20	$this->diffIndexes($that),
420	20	$this->diffForeigns($that),
421	20	$this->diffOptions($that, [
422	20	'alterEngine' => $flags['alterEngine']
423		])
424		);
425
426	20	if (count($alters) === 0) {
427	2	return [];
428		}
429
430	18	return ["ALTER TABLE " . Token::escapeIdentifier($this->name) . "\n" . implode(",\n", $alters)];
431		}
432
433		/**
434		* @param CreateTable $that
435		* @return array
436		*/
437	20	private function diffColumns(CreateTable $that)
438		{
439	20	$alters = [];
440	20	$permutation = [];
441	20	foreach (array_keys($this->columns) as $columnName) {
442	20	if (array_key_exists($columnName, $that->columns)) {
443	20	$permutation[] = $columnName;
444		} else {
445	1	$alters[] = "DROP COLUMN " . Token::escapeIdentifier($columnName);
446		}
447		}
448
449	20	$prevColumn = null;
450	20	$thatPosition = " FIRST";
451	20	$j = 0;
452	20	foreach ($that->columns as $columnName => $column) {
453	20	if (array_key_exists($columnName, $this->columns)) {
454		// An existing column is being changed
455	20	$thisDefinition = $this->columns[$columnName]->toString($this->getCollation());
456	20	$thatDefinition = $that->columns[$columnName]->toString($that->getCollation());
457
458		// about to 'add' $columnName - get its location in the currently
459		// permuted state of the tabledef
460	20	$i = array_search($columnName, $permutation);
461
462		// figure out the column it currently sits after, in case we
463		// need to change it
464	20	$thisPosition = ($i === 0) ? " FIRST" : " AFTER " . Token::escapeIdentifier($permutation[$i - 1]);
465
466	20	if ($thisDefinition !== $thatDefinition \|\|
467	20	$thisPosition !== $thatPosition
468		) {
469	8	$alter = "MODIFY COLUMN " . $thatDefinition;
470
471		// position has changed
472	8	if ($thisPosition !== $thatPosition) {
473	3	$alter .= $thatPosition;
474
475		// We need to update our permutation to reflect the new position.
476		// Column is being inserted at position $j, and is currently residing at $i.
477
478		// remove from current location
479	3	array_splice($permutation, /** @scrutinizer ignore-type */ $i, 1, []);
480
481		// insert at new location
482	3	array_splice($permutation, $j, 0, $columnName);
483		}
484
485	20	$alters[] = $alter;
486		}
487		} else {
488		// A new column is being added
489	3	$alter = "ADD COLUMN " . $column->toString($this->getCollation());
490	3	if ($j < count($permutation)) {
491	2	$alter .= $thatPosition;
492		}
493	3	$alters[] = $alter;
494
495	3	$i = is_null($prevColumn) ? 0 : 1 + array_search($prevColumn, $permutation);
496	3	array_splice($permutation, $i, 0, [$columnName]);
497		}
498
499	20	$prevColumn = $columnName;
500	20	$thatPosition = " AFTER " . Token::escapeIdentifier($prevColumn);
501	20	$j++;
502		}
503
504	20	return $alters;
505		}
506
507		/**
508		* @param CreateTable $that
509		* @return array
510		*/
511	20	private function diffIndexes(CreateTable $that)
512		{
513	20	$alters = [];
514
515	20	foreach ($this->indexes as $indexName => $index) {
516	4	if (!array_key_exists($indexName, $that->indexes) \|\|
517	4	$index->toString() !== $that->indexes[$indexName]->toString()
518		) {
519	4	switch ($index->type) {
520	4	case 'PRIMARY KEY':
521	1	$alter = "DROP PRIMARY KEY";
522	1	break;
523
524		default:
525	3	$alter = "DROP KEY " . Token::escapeIdentifier($indexName);
526	3	break;
527		}
528	4	$alters[] = $alter;
529		}
530		}
531
532	20	foreach ($that->indexes as $indexName => $index) {
533	4	if (!array_key_exists($indexName, $this->indexes) \|\|
534	4	$index->toString() !== $this->indexes[$indexName]->toString()
535		) {
536	4	$alters[] = "ADD " . $index->toString();
537		}
538		}
539
540	20	return $alters;
541		}
542
543		/**
544		* @param CreateTable $that
545		* @return array
546		*/
547	20	private function diffForeigns(CreateTable $that)
548		{
549	20	$alters = [];
550
551	20	foreach ($this->foreigns as $foreignName => $foreign) {
552		if (!array_key_exists($foreignName, $that->foreigns) \|\|
553		$foreign->toString() !== $that->foreigns[$foreignName]->toString()
554		) {
555		$alters[] = "DROP FOREIGN KEY " . Token::escapeIdentifier($foreignName);
556		}
557		}
558
559	20	foreach ($that->foreigns as $foreignName => $foreign) {
560		if (!array_key_exists($foreignName, $this->foreigns) \|\|
561		$foreign->toString() !== $this->foreigns[$foreignName]->toString()
562		) {
563		$alters[] = "ADD " . $foreign->toString();
564		}
565		}
566
567	20	return $alters;
568		}
569
570		/**
571		* @param CreateTable $that
572		* @param array $flags
573		* @return array
574		*/
575	20	private function diffOptions(CreateTable $that, array $flags = [])
576		{
577		$flags += [
578	20	'alterEngine' => true
579		];
580	20	$diff = $this->options->diff($that->options, [
581	20	'alterEngine' => $flags['alterEngine']
582		]);
583	20	return ($diff == '') ? [] : [$diff];
584		}
585		}
586

graze / morphism

GitHub Access Token became invalid

Pull Request — master (#61)

CreateTable::diffForeigns() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like