N98\Magento\Command\Database\ImportCommand

Complexity

Total Complexity

25

Size/Duplication

Total Lines	195
Duplicated Lines	7.69 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	3
Bugs	2	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
B	configure()	0	25	1
A	isEnabled()	0	4	1
C	optimize()	15	50	9
C	execute()	0	51	9
A	asText()	0	5	1
A	checkFilename()	0	9	2
A	doImport()	0	14	2

<?php

namespace N98\Magento\Command\Database;

use Exception;
use N98\Magento\Command\Database\Compressor\AbstractCompressor;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;

class ImportCommand extends AbstractDatabaseCommand
{
    protected function configure()
    {
        $this
            ->setName('db:import')
            ->addArgument('filename', InputArgument::OPTIONAL, 'Dump filename')
            ->addOption('compression', 'c', InputOption::VALUE_REQUIRED, 'The compression of the specified file')
            ->addOption('only-command', null, InputOption::VALUE_NONE, 'Print only mysql command. Do not execute')
            ->addOption('only-if-empty', null, InputOption::VALUE_NONE, 'Imports only if database is empty')
            ->addOption(
                'optimize',
                null,
                InputOption::VALUE_NONE,
                'Convert verbose INSERTs to short ones before import (not working with compression)'
            )
            ->addOption('drop', null, InputOption::VALUE_NONE, 'Drop and recreate database before import')
            ->addOption('drop-tables', null, InputOption::VALUE_NONE, 'Drop tables before import')
            ->setDescription('Imports database with mysql cli client according to database defined in local.xml');

        $help = <<<HELP
Imports an SQL file with mysql cli client into current configured database.

You need to have MySQL client tools installed on your system.
HELP;
        $this->setHelp($help);
    }

    /**
     * @return bool
     */
    public function isEnabled()
    {
        return function_exists('exec');
    }

    /**
     * Optimize a dump by converting single INSERTs per line to INSERTs with multiple lines
     *
     * @param $fileName
     * @return string temporary filename
     */
    protected function optimize($fileName)
    {
        $in = fopen($fileName, 'r');
        $result = tempnam(sys_get_temp_dir(), 'dump') . '.sql';
        $out = fopen($result, 'w');

        $currentTable = '';
        $maxlen = 8 * 1024 * 1024; // 8 MB
        $len = 0;
        while ($line = fgets($in)) {
            if (strtolower(substr($line, 0, 11)) == 'insert into') {
                preg_match('/^insert into `(.*)` \(.*\) values (.*);/i', $line, $m);

                if (count($m) < 3) { // fallback for very long lines or other cases where the preg_match fails

This code seems to be duplicated across your project.

                    if ($currentTable != '') {
                        fwrite($out, ";\n");
                    }
                    fwrite($out, $line);
                    $currentTable = '';
                    continue;
                }

                $table = $m[1];
                $values = $m[2];

                if ($table != $currentTable or ($len > $maxlen - 1000)) {

Using logical operators such as or instead of || is generally not recommended.

                    if ($currentTable != '') {
                        fwrite($out, ";\n\n");
                    }
                    $currentTable = $table;
                    $insert = 'INSERT INTO `' . $table . '` VALUES ' . $values;
                    fwrite($out, $insert);
                    $len = strlen($insert);
                } else {
                    fwrite($out, ',' . $values);
                    $len += strlen($values) + 1;
                }
            } else {

This code seems to be duplicated across your project.

                if ($currentTable != '') {
                    fwrite($out, ";\n");
                    $currentTable = '';
                }
                fwrite($out, $line);
            }
        }
        fclose($in);
        fclose($out);

        return $result;
    }

    /**
     * @param InputInterface $input
     * @param OutputInterface $output
     * @return int|null|void
     * @throws Exception
     */
    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $this->detectDbSettings($output);
        $this->writeSection($output, 'Import MySQL Database');
        $dbHelper = $this->getHelper('database');

        $fileName = $this->checkFilename($input);

        $compressor = AbstractCompressor::create($input->getOption('compression'));

        // create import command
        $exec = $compressor->getDecompressingCommand(
            'mysql ' . $dbHelper->getMysqlClientToolConnectionString(),
            $fileName
        );
        if ($input->getOption('only-command')) {
            $output->writeln($exec);

            return;
        } else {
            if ($input->getOption('only-if-empty')
                && count($dbHelper->getTables()) > 0
            ) {
                $output->writeln('<comment>Skip import. Database is not empty</comment>');

                return;
            }
        }

        if ($input->getOption('optimize')) {
            if ($input->getOption('compression')) {
                throw new Exception('Options --compression and --optimize are not compatible');
            }
            $output->writeln('<comment>Optimizing <info>' . $fileName . '</info> to temporary file');
            $fileName = $this->optimize($fileName);
        }

        if ($input->getOption('drop')) {
            $dbHelper->dropDatabase($output);
            $dbHelper->createDatabase($output);
        }
        if ($input->getOption('drop-tables')) {
            $dbHelper->dropTables($output);
        }

        $this->doImport($output, $fileName, $exec);

        if ($input->getOption('optimize')) {
            unlink($fileName);
        }
    }

    public function asText()
    {
        return parent::asText() . "\n" .

The method Symfony\Component\Console\Command\Command::asText() has been deprecated with message: Deprecated since version 2.3, to be removed in 3.0.

        $this->getCompressionHelp();
    }

    /**
     * @param InputInterface $input
     *
     * @return mixed
     * @throws \InvalidArgumentException
     */
    protected function checkFilename(InputInterface $input)
    {
        $fileName = $input->getArgument('filename');
        if (!file_exists($fileName)) {
            throw new \InvalidArgumentException('File does not exist');
        }

        return $fileName;
    }

    /**
     * @param OutputInterface $output
     * @param string $fileName
     * @param string $exec
     *
     * @return void
     */
    protected function doImport(OutputInterface $output, $fileName, $exec)
    {
        $returnValue = null;
        $commandOutput = null;
        $output->writeln(
            '<comment>Importing SQL dump <info>' . $fileName . '</info> to database <info>'
            . $this->dbSettings['dbname'] . '</info>'
        );
        exec($exec, $commandOutput, $returnValue);
        if ($returnValue <> 0) {

It seems like you are loosely comparing $returnValue of type integer|null to 0; this is ambiguous as not only 0 == 0 is true, but null == 0 is true, too. Consider using a strict comparison ===.

            $output->writeln('<error>' . implode(PHP_EOL, $commandOutput) . '</error>');
        }
        $output->writeln('<info>Finished</info>');
    }
}