MysqlDump::parseFromPaths() - Code Metrics - Inspection of "Merge pull request #65 from graze/utf8mb3" - graze/morphism - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( d274d7...b4c702 )

unknown

created 2024-04-17 15:38 UTC

MysqlDump::parseFromPaths() B

↳ Parent: MysqlDump

Complexity

Conditions	9
Paths	72

Size

Total Lines	35
Code Lines	22

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	90

Importance

Changes	3
Bugs	0	Features	0

Metric	Value
cc	9
eloc	22
nc	72
nop	4
dl	0
loc	35
rs	8.0555
c	3
b	0
f	0
ccs	0
cts	32
cp	0
crap	90

<?php
namespace Graze\Morphism\Parse;

use GlobIterator;
use RuntimeException;

/**
 * Represents a dump of one or more databases.
 */
class MysqlDump
{
    /**
     * @var CreateDatabase[]
     *
     * indexed by (string) database name; when enumerated, reflects the order
     * in which the databases declarations were parsed.
     */
    public $databases = [];

    /** @var CreateDatabase */
    private $database = null;
    /** @var string */
    private $defaultDatabaseName = '';
    /** @var string */
    private $defaultEngine = 'InnoDB';
    /** @var CollationInfo */
    private $defaultCollation = null;
    /** @var bool */
    private $addIndexForForeignKey = true;

    /**
     * Constructor
     */
    public function __construct()
    {
        $this->defaultCollation = new CollationInfo();
    }

    /**
     * Parses one or more MySQL dump files from the specified paths.
     *
     * Each path may refer either to a file, or to a directory from which each
     * contained file is parsed. There is no recursion into sub-directories.
     *
     * @param string[]    $paths            files or directories to parse
     * @param string|null $defaultEngine    default database engine to use (e.g. InnoDB)
     * @param string|null $defaultCollation default collation to use (e.g. utf8)
     * @param string|null $defaultDatabaseName database name to use if unspecified in stream
     * @return MysqlDump
     */
    public static function parseFromPaths(array $paths, $defaultEngine = null, $defaultCollation = null, $defaultDatabaseName = null)
    {
        $dump = new self;
        if (!is_null($defaultEngine)) {
            $dump->setDefaultEngine($defaultEngine);
        }
        if (!is_null($defaultCollation)) {
            $dump->setDefaultCollation(new CollationInfo($defaultCollation));
        }
        if (!is_null($defaultDatabaseName)) {
            $dump->setDefaultDatabase($defaultDatabaseName);
        }

        $files = [];
        foreach ($paths as $path) {
            if (is_dir($path)) {
                foreach (new GlobIterator("$path/*.sql") as $fileInfo) {
                    $files[] = $fileInfo->getPathname();
                }
            } else {
                $files[] = $path;
            }
        }

        foreach ($files as $file) {
            $stream = TokenStream::newFromFile($file);
            try {
                $dump->parse($stream);
            } catch (RuntimeException $e) {
                $message = $stream->contextualise($e->getMessage());
                throw new RuntimeException($message);
            }
        }

        return $dump;
    }

    /**
     * Sets the name to use for the database if none is specified in the stream.
     *
     * @param string $databaseName
     */
    public function setDefaultDatabase($databaseName)
    {
        $this->defaultDatabaseName = $databaseName;
    }

    /**
     * Sets the default storage engine to assume when the ENGINE= option is
     * not specified in a CREATE TABLE.
     *
     * @param string $engine  name of storage engine, e.g. 'InnoDB'
     */
    public function setDefaultEngine($engine)
    {
        $this->defaultEngine = $engine;
    }

    /**
     * Sets whether to add an index for each foreign key if one isn't defined, this is the default behaviour of MySQL.
     *
     * @param bool $addIndexForForeignKey
     */
    public function setAddIndexForForeignKey($addIndexForForeignKey)
    {
        $this->addIndexForForeignKey = $addIndexForForeignKey;
    }

    /**
     * Sets the default collation to assume when no collation or charset
     * is specified in CREATE DATABASE or CREATE TABLE.
     *
     * @param CollationInfo $collation
     */
    public function setDefaultCollation(CollationInfo $collation)
    {
        $this->defaultCollation = clone $collation;
    }

    /**
     * Parses a sequence of CREATE DATABASE and CREATE TABLE clauses from $stream.
     *
     * All other SQL statements and comments are skipped. After a CREATE DATABASE,
     * any subsequent CREATE TABLEs are assumed to belong to that database. Any
     * CREATE TABLEs encountered before the first CREATE DATABASE are assigned to
     * an anonymous dummy database named ''.
     *
     * @param TokenStream $stream
     * @param array $flags
     */
    public function parse(TokenStream $stream, array $flags = [])
    {
        $flags += [
            'matchTables' => [
                'include' => '',
                'exclude' => '',
            ]
        ];

        while (true) {
            if ($stream->peek('CREATE DATABASE')) {
                $this->database = new CreateDatabase($this->defaultCollation);
                $this->database->parse($stream);
                $stream->expect(Token::SYMBOL, ';');

                $this->databases[$this->database->name] = $this->database;
            } elseif ($stream->peek('CREATE TABLE')) {
                if (is_null($this->database)) {
                    $name = $this->defaultDatabaseName;
                    $this->database = new CreateDatabase($this->defaultCollation);
                    $this->database->name = $name;
                    $this->databases[$name] = $this->database;
                }
                $table = new CreateTable($this->database->getCollation());
                $table->setDefaultEngine($this->defaultEngine);
                $table->setAddIndexForForeignKey($this->addIndexForForeignKey);
                $table->parse($stream);
                $stream->expect(Token::SYMBOL, ';');

                $includeTablesRegex = $flags['matchTables']['include'];
                $excludeTablesRegex = $flags['matchTables']['exclude'];
                if (($includeTablesRegex == '' || preg_match($includeTablesRegex, $table->getName())) &&
                    ($excludeTablesRegex == '' || !preg_match($excludeTablesRegex, $table->getName()))
                ) {
                    $this->database->addTable($table);
                }
            } elseif (!$this->skipQuery($stream)) {
                break;
            }
        }
    }

    /**
     * Skip any statements which aren't create database/table statements.
     *
     * @param TokenStream $stream
     * @return bool
     */
    private function skipQuery(TokenStream $stream)
    {
        while (true) {
            $token = $stream->nextToken();
            if ($token->isEof()) {
                return false;
            }
            if ($token->eq(Token::SYMBOL, ';')) {
                return true;
            }
        }

        // Shoud never get here, but treat it as EOF
        return false;
    }

    /**
     * Returns an array of SQL DDL statements for creating the database schema.
     *
     * @return string[]
     */
    public function getDDL()
    {
        $ddl = [];

        foreach ($this->databases as $database) {
            if ($database->name !== '') {
                $ddl = array_merge($ddl, $database->getDDL());
                $ddl[] = "USE " . Token::escapeIdentifier($database->name);
            }
            foreach ($database->tables as $table) {
                $ddl = array_merge($ddl, $table->getDDL());
            }
        }

        return $ddl;
    }

    /**
     * Returns an array of SQL DDL statements for transforming the database
     * schema into the one represented by $that.
     *
     * $flags           |
     * :----------------|
     * 'createDatabase' | (bool) include 'CREATE DATABASE' statements and dependent CREATE TABLEs [default: true]
     * 'dropDatabase'   | (bool) include 'DROP DATABASE' statements [default: true]
     * 'createTable'    | (bool) include 'CREATE TABLE' statements [default: true]
     * 'dropTable'      | (bool) include 'DROP TABLE' statements [default: true]
     * 'alterEngine'    | (bool) include 'ALTER TABLE ... ENGINE=' [default: true]
     * 'matchTables'    | [$database => ['include' => $regex, 'exclude' => $regex], ...] tables to include / exclude
     *
     * @param MysqlDump $that
     * @param bool[] $flags controls what to include in the generated DDL
     * @return string[]
     */
    public function diff(MysqlDump $that, array $flags = [])
    {
        $flags += [
            'createDatabase' => true,
            'dropDatabase'   => true,
            'createTable'    => true,
            'dropTable'      => true,
            'alterEngine'    => true,
            'matchTables'    => [
                'include' => '',
                'exclude' => '',
            ],
        ];

        $thisDatabaseNames = array_keys($this->databases);
        $thatDatabaseNames = array_keys($that->databases);

        $commonDatabaseNames  = array_intersect($thisDatabaseNames, $thatDatabaseNames);
        $droppedDatabaseNames = array_diff($thisDatabaseNames, $thatDatabaseNames);
        $createdDatabaseNames = array_diff($thatDatabaseNames, $thisDatabaseNames);

        $diff = [];

        if ($flags['dropDatabase'] && count($droppedDatabaseNames) > 0) {
            foreach ($droppedDatabaseNames as $databaseName) {
                $diff[] = "DROP DATABASE IF EXISTS " . Token::escapeIdentifier($databaseName);
            }
        }

        if ($flags['createDatabase']) {
            foreach ($createdDatabaseNames as $databaseName) {
                $matchTables = $flags['matchTables'][$databaseName];
                $includeTablesRegex = $matchTables['include'];
                $excludeTablesRegex = $matchTables['exclude'];
                $thatDatabase = $that->databases[$databaseName];
                $diff[] = $thatDatabase->getDDL();
                $diff[] = "USE " . Token::escapeIdentifier($databaseName);
                foreach ($thatDatabase->tables as $table) {
                    if (($includeTablesRegex == '' || preg_match($includeTablesRegex, $table->getName())) &&
                        ($excludeTablesRegex == '' || !preg_match($excludeTablesRegex, $table->getName()))
                    ) {
                        $diff[] = $table->getDDL();
                    }
                }
            }
        }

        foreach ($commonDatabaseNames as $databaseName) {
            $matchTables = $flags['matchTables'][$databaseName];
            $thisDatabase = $this->databases[$databaseName];
            $thatDatabase = $that->databases[$databaseName];
            $databaseDiff = $thisDatabase->diff($thatDatabase, [
                'createTable' => $flags['createTable'],
                'dropTable'   => $flags['dropTable'],
                'alterEngine' => $flags['alterEngine'],
                'matchTables' => $matchTables,
            ]);

            if ($databaseDiff !== '') {
                if ($databaseName !== $this->defaultDatabaseName) {
                    $diff[] = "USE " . Token::escapeIdentifier($databaseName);
                }
                $diff = array_merge($diff, $databaseDiff);
            }
        }

        return $diff;
    }
}


1			<?php
2			namespace Graze\Morphism\Parse;
3
4			use GlobIterator;
5			use RuntimeException;
6
7			/**
8			* Represents a dump of one or more databases.
9			*/
10			class MysqlDump
11			{
12			/**
13			* @var CreateDatabase[]
14			*
15			* indexed by (string) database name; when enumerated, reflects the order
16			* in which the databases declarations were parsed.
17			*/
18			public $databases = [];
19
20			/** @var CreateDatabase */
21			private $database = null;
22			/** @var string */
23			private $defaultDatabaseName = '';
24			/** @var string */
25			private $defaultEngine = 'InnoDB';
26			/** @var CollationInfo */
27			private $defaultCollation = null;
28			/** @var bool */
29			private $addIndexForForeignKey = true;
30
31			/**
32			* Constructor
33			*/
34			public function __construct()
35			{
36			$this->defaultCollation = new CollationInfo();
37			}
38
39			/**
40			* Parses one or more MySQL dump files from the specified paths.
41			*
42			* Each path may refer either to a file, or to a directory from which each
43			* contained file is parsed. There is no recursion into sub-directories.
44			*
45			* @param string[] $paths files or directories to parse
46			* @param string\|null $defaultEngine default database engine to use (e.g. InnoDB)
47			* @param string\|null $defaultCollation default collation to use (e.g. utf8)
48			* @param string\|null $defaultDatabaseName database name to use if unspecified in stream
49			* @return MysqlDump
50			*/
51			public static function parseFromPaths(array $paths, $defaultEngine = null, $defaultCollation = null, $defaultDatabaseName = null)
52			{
53			$dump = new self;
54			if (!is_null($defaultEngine)) {
55			$dump->setDefaultEngine($defaultEngine);
56			}
57			if (!is_null($defaultCollation)) {
58			$dump->setDefaultCollation(new CollationInfo($defaultCollation));
59			}
60			if (!is_null($defaultDatabaseName)) {
61			$dump->setDefaultDatabase($defaultDatabaseName);
62			}
63
64			$files = [];
65			foreach ($paths as $path) {
66			if (is_dir($path)) {
67			foreach (new GlobIterator("$path/*.sql") as $fileInfo) {
68			$files[] = $fileInfo->getPathname();
69			}
70			} else {
71			$files[] = $path;
72			}
73			}
74
75			foreach ($files as $file) {
76			$stream = TokenStream::newFromFile($file);
77			try {
78			$dump->parse($stream);
79			} catch (RuntimeException $e) {
80			$message = $stream->contextualise($e->getMessage());
81			throw new RuntimeException($message);
82			}
83			}
84
85			return $dump;
86			}
87
88			/**
89			* Sets the name to use for the database if none is specified in the stream.
90			*
91			* @param string $databaseName
92			*/
93			public function setDefaultDatabase($databaseName)
94			{
95			$this->defaultDatabaseName = $databaseName;
96			}
97
98			/**
99			* Sets the default storage engine to assume when the ENGINE= option is
100			* not specified in a CREATE TABLE.
101			*
102			* @param string $engine name of storage engine, e.g. 'InnoDB'
103			*/
104			public function setDefaultEngine($engine)
105			{
106			$this->defaultEngine = $engine;
107			}
108
109			/**
110			* Sets whether to add an index for each foreign key if one isn't defined, this is the default behaviour of MySQL.
111			*
112			* @param bool $addIndexForForeignKey
113			*/
114			public function setAddIndexForForeignKey($addIndexForForeignKey)
115			{
116			$this->addIndexForForeignKey = $addIndexForForeignKey;
117			}
118
119			/**
120			* Sets the default collation to assume when no collation or charset
121			* is specified in CREATE DATABASE or CREATE TABLE.
122			*
123			* @param CollationInfo $collation
124			*/
125			public function setDefaultCollation(CollationInfo $collation)
126			{
127			$this->defaultCollation = clone $collation;
128			}
129
130			/**
131			* Parses a sequence of CREATE DATABASE and CREATE TABLE clauses from $stream.
132			*
133			* All other SQL statements and comments are skipped. After a CREATE DATABASE,
134			* any subsequent CREATE TABLEs are assumed to belong to that database. Any
135			* CREATE TABLEs encountered before the first CREATE DATABASE are assigned to
136			* an anonymous dummy database named ''.
137			*
138			* @param TokenStream $stream
139			* @param array $flags
140			*/
141			public function parse(TokenStream $stream, array $flags = [])
142			{
143			$flags += [
144			'matchTables' => [
145			'include' => '',
146			'exclude' => '',
147			]
148			];
149
150			while (true) {
151			if ($stream->peek('CREATE DATABASE')) {
152			$this->database = new CreateDatabase($this->defaultCollation);
153			$this->database->parse($stream);
154			$stream->expect(Token::SYMBOL, ';');
155
156			$this->databases[$this->database->name] = $this->database;
157			} elseif ($stream->peek('CREATE TABLE')) {
158			if (is_null($this->database)) {
159			$name = $this->defaultDatabaseName;
160			$this->database = new CreateDatabase($this->defaultCollation);
161			$this->database->name = $name;
162			$this->databases[$name] = $this->database;
163			}
164			$table = new CreateTable($this->database->getCollation());
165			$table->setDefaultEngine($this->defaultEngine);
166			$table->setAddIndexForForeignKey($this->addIndexForForeignKey);
167			$table->parse($stream);
168			$stream->expect(Token::SYMBOL, ';');
169
170			$includeTablesRegex = $flags['matchTables']['include'];
171			$excludeTablesRegex = $flags['matchTables']['exclude'];
172			if (($includeTablesRegex == '' \|\| preg_match($includeTablesRegex, $table->getName())) &&
173			($excludeTablesRegex == '' \|\| !preg_match($excludeTablesRegex, $table->getName()))
174			) {
175			$this->database->addTable($table);
176			}
177			} elseif (!$this->skipQuery($stream)) {
178			break;
179			}
180			}
181			}
182
183			/**
184			* Skip any statements which aren't create database/table statements.
185			*
186			* @param TokenStream $stream
187			* @return bool
188			*/
189			private function skipQuery(TokenStream $stream)
190			{
191			while (true) {
192			$token = $stream->nextToken();
193			if ($token->isEof()) {
194			return false;
195			}
196			if ($token->eq(Token::SYMBOL, ';')) {
197			return true;
198			}
199			}
200
201			// Shoud never get here, but treat it as EOF
202			return false;
203			}
204
205			/**
206			* Returns an array of SQL DDL statements for creating the database schema.
207			*
208			* @return string[]
209			*/
210			public function getDDL()
211			{
212			$ddl = [];
213
214			foreach ($this->databases as $database) {
215			if ($database->name !== '') {
216			$ddl = array_merge($ddl, $database->getDDL());
217			$ddl[] = "USE " . Token::escapeIdentifier($database->name);
218			}
219			foreach ($database->tables as $table) {
220			$ddl = array_merge($ddl, $table->getDDL());
221			}
222			}
223
224			return $ddl;
225			}
226
227			/**
228			* Returns an array of SQL DDL statements for transforming the database
229			* schema into the one represented by $that.
230			*
231			* $flags \|
232			* :----------------\|
233			* 'createDatabase' \| (bool) include 'CREATE DATABASE' statements and dependent CREATE TABLEs [default: true]
234			* 'dropDatabase' \| (bool) include 'DROP DATABASE' statements [default: true]
235			* 'createTable' \| (bool) include 'CREATE TABLE' statements [default: true]
236			* 'dropTable' \| (bool) include 'DROP TABLE' statements [default: true]
237			* 'alterEngine' \| (bool) include 'ALTER TABLE ... ENGINE=' [default: true]
238			* 'matchTables' \| [$database => ['include' => $regex, 'exclude' => $regex], ...] tables to include / exclude
239			*
240			* @param MysqlDump $that
241			* @param bool[] $flags controls what to include in the generated DDL
242			* @return string[]
243			*/
244			public function diff(MysqlDump $that, array $flags = [])
245			{
246			$flags += [
247			'createDatabase' => true,
248			'dropDatabase' => true,
249			'createTable' => true,
250			'dropTable' => true,
251			'alterEngine' => true,
252			'matchTables' => [
253			'include' => '',
254			'exclude' => '',
255			],
256			];
257
258			$thisDatabaseNames = array_keys($this->databases);
259			$thatDatabaseNames = array_keys($that->databases);
260
261			$commonDatabaseNames = array_intersect($thisDatabaseNames, $thatDatabaseNames);
262			$droppedDatabaseNames = array_diff($thisDatabaseNames, $thatDatabaseNames);
263			$createdDatabaseNames = array_diff($thatDatabaseNames, $thisDatabaseNames);
264
265			$diff = [];
266
267			if ($flags['dropDatabase'] && count($droppedDatabaseNames) > 0) {
268			foreach ($droppedDatabaseNames as $databaseName) {
269			$diff[] = "DROP DATABASE IF EXISTS " . Token::escapeIdentifier($databaseName);
270			}
271			}
272
273			if ($flags['createDatabase']) {
274			foreach ($createdDatabaseNames as $databaseName) {
275			$matchTables = $flags['matchTables'][$databaseName];
276			$includeTablesRegex = $matchTables['include'];
277			$excludeTablesRegex = $matchTables['exclude'];
278			$thatDatabase = $that->databases[$databaseName];
279			$diff[] = $thatDatabase->getDDL();
280			$diff[] = "USE " . Token::escapeIdentifier($databaseName);
281			foreach ($thatDatabase->tables as $table) {
282			if (($includeTablesRegex == '' \|\| preg_match($includeTablesRegex, $table->getName())) &&
283			($excludeTablesRegex == '' \|\| !preg_match($excludeTablesRegex, $table->getName()))
284			) {
285			$diff[] = $table->getDDL();
286			}
287			}
288			}
289			}
290
291			foreach ($commonDatabaseNames as $databaseName) {
292			$matchTables = $flags['matchTables'][$databaseName];
293			$thisDatabase = $this->databases[$databaseName];
294			$thatDatabase = $that->databases[$databaseName];
295			$databaseDiff = $thisDatabase->diff($thatDatabase, [
296			'createTable' => $flags['createTable'],
297			'dropTable' => $flags['dropTable'],
298			'alterEngine' => $flags['alterEngine'],
299			'matchTables' => $matchTables,
300			]);
301
302			if ($databaseDiff !== '') {
303			if ($databaseName !== $this->defaultDatabaseName) {
304			$diff[] = "USE " . Token::escapeIdentifier($databaseName);
305			}
306			$diff = array_merge($diff, $databaseDiff);
307			}
308			}
309
310			return $diff;
311			}
312			}
313

graze / morphism

GitHub Access Token became invalid

Push — master ( d274d7...b4c702 )

MysqlDump::parseFromPaths() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like