DbDiff - Code Metrics - fwolf/fwlib - Measure and Improve Code Quality continuously with Scrutinizer

DbDiff F
last analyzed 2019-05-09 15:53 UTC

↳ Parent: Project
Complexity

Total Complexity
Size/Duplication

Total Lines	775
Duplicated Lines	24.52 %
Coupling/Cohesion

Components	1
Dependencies	4
Importance

Changes
Metric	Value
dl	190
loc	775
rs	1.825
c	0
b	0
f	0
wmc	91
lcom	1
cbo	4
22 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	checkPkArray()	0	22	4
B	commit()	37	37	6
A	compare()	0	34	5
A	compareRow()	0	32	4
B	compareRowColumn()	0	41	11
B	compareRowMode()	0	31	11
A	compareRowPk()	0	19	3
A	compareTable()	0	32	3
A	execute()	0	18	3
A	export()	0	12	1
B	generateCommitSql()	58	58	10
B	generateRollbackSql()	58	58	10
A	getDiff()	0	4	1
A	getRowCount()	0	4	1
A	import()	0	20	2
A	isCommitted()	0	4	1
A	isExecuted()	0	4	1
A	isRollbacked()	0	4	1
A	prepareRowOld()	0	30	5
A	reset()	0	8	1
B	rollback()	37	37	6
How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.
Common duplication problems, and corresponding solutions are:
If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class
Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.
Complex classes like DbDiff often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use DbDiff, and based on these observations, apply Extract Interface, too.
<?php
namespace Fwlib\Db;

use Fwlib\Bridge\Adodb;
use Fwlib\Util\UtilContainerAwareTrait;

/**
 * Compare db data before and after write
 *
 * Diff data array format:
 * {table: [{mode, 'pk': pk, 'column': column}]}
 *
 * mode is one of INSERT, DELETE, UPDATE.
 *
 * pk is array of primary key and their new/old value, format:
 * {pk: {new, old}}.
 *
 * column is array of other columns changed, format:
 * {column: {new, old}}.
 *
 * @deprecated
 *
 * @copyright   Copyright 2012-2015 Fwolf
 * @license     http://www.gnu.org/licenses/lgpl.html LGPL-3.0+
 */
class DbDiff
{
    use UtilContainerAwareTrait;


    /**
     * Counter of DbDiff changed rows
     *
     * @var int
     */
    protected $rowCount = 0;

    /**
     * @var Adodb
     */
    protected $db = null;

    /**
     * Diff data array
     *
     * @var array
     */
    protected $diff = [];

    /**
     * DbDiff execute status
     *
     * 0    not executed
     * 100  committed
     * -100 rollbacked
     *
     * @var int
     */
    protected $executeStatus = 0;


    /**
     * Constructor
     *
     * @param   Adodb   $db
     */
    public function __construct($db)
    {
        $this->db = $db;
    }


    /**
     * Check PK array is valid or throw exception
     *
     * @param   string  $table
     * @param   array   $pkArray
     * @param   array   &$rowArray
     */
    protected function checkPkArray($table, array $pkArray, array &$rowArray)
    {
        if (empty($pkArray)) {
            throw new \Exception(
                "Table $table must have PK defined"
            );
        }

        // array_intersect() is less loop than array_key_exist() check.
        // Can't use isset when do array_key_exist(), bcs isset(null) == false
        foreach ($rowArray as $index => &$row) {
            if (count($pkArray) !=
                count(array_intersect($pkArray, array_keys($row)))
            ) {
                throw new \Exception(
                    "PK not all assigned in new array," .
                    " table $table index $index"
                );
            }
        }
        unset($row);
    }


    /**
     * Commit diff result, change db
     *
     * @return  DbDiff
     */
    public function commit()

    {
        if (empty($this->diff)) {
            throw new \Exception('No diff data');
        }

        if ($this->isCommitted()) {
            throw new \Exception(
                'Committed DbDiff can\'t commit again'
            );
        }

        $sqlArray = $this->generateCommitSql();

        $this->db->BeginTrans();
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }

        try {
            foreach ((array)$sqlArray as $sql) {
                $this->db->execute($sql);

                if (0 != $this->db->getErrorCode()) {
                    throw new \Exception($this->db->getErrorMessage());
                }
            }

            $this->db->CommitTrans();
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            $this->rowCount = count($sqlArray);
            $this->executeStatus = 100;

        } catch (\Exception $e) {
            $this->db->RollbackTrans();
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }

            throw new \Exception($e->getMessage());
        }

        return $this;
    }


    /**
     * Compare new data with old data in db
     *
     * New/old array are all assoc, index by table column.  PK column must
     * included in new array, but its value can be null.
     *
     * In new array, null PK value means DELETE operate.
     * In old array, null PK value means INSERT operate.
     *
     * Multi table and row supported.
     *
     * New/old array format:
     * {table: [{column: value}]}
     * If only need to change a single row, can use simple format:
     * {table: {column: value}}
     *
     * If old array is null, will read its value from db by Pk in new array.
     *
     * Row index in new/old array must match, it is used to connect same row
     * in new and old data, so either use a meaningful row index, or use default
     * integer index and keep same data order in new and old.
     *
     * @param   array   $dataNew
     * @param   array   $dataOld
     * @return  DbDiff
     */
    public function compare(array $dataNew, array $dataOld = null)
    {
        if (empty($dataNew)) {
            throw new \Exception('New data array can\'t be empty');
        }


        $diff = [];
        foreach ($dataNew as $table => &$rowArrayNew) {
            // Convert row array to 2-dim array
            if (!is_array(current($rowArrayNew))) {
                $rowArrayNew = [$rowArrayNew];
            }

            $pkArray = (array)$this->db->getMetaPrimaryKey($table);
            $this->checkPkArray($table, $pkArray, $rowArrayNew);

            $diffOfTable = $this->compareTable(
                $table,
                $pkArray,
                $rowArrayNew,
                $dataOld
            );

            if (!empty($diffOfTable)) {
                $diff[$table] = $diffOfTable;
            }
        }
        unset($rowArrayNew);

        $this->diff = $diff;

        return $this;
    }


    /**
     * Compare different of a single row
     *
     * $rowNew MUST contain all PK columns.
     *
     * @param   array   &$rowNew
     * @param   array   $pkArray
     * @param   array   &$rowOld
     * @return  array
     */
    protected function compareRow(
        array &$rowNew,
        array $pkArray,
        array &$rowOld = null
    ) {
        $mode = $this->compareRowMode($rowNew, $pkArray, $rowOld);

        $pkDiff = $this->compareRowPk($rowNew, $pkArray, $rowOld);

        $columnArray = array_keys($rowNew);
        if (!is_null($rowOld)) {
            $columnArray = array_merge(array_keys($rowOld));
        }
        $columnDiff = $this->compareRowColumn(
            $mode,
            $rowNew,
            $columnArray,
            $rowOld
        );

        // UPDATE with no column change will be skipped
        if ('UPDATE' == $mode && empty($columnDiff)) {
            return null;

        } else {
            return [
                'mode'   => $mode,
                'pk'     => $pkDiff,
                'column' => $columnDiff,
            ];
        }
    }


    /**
     * Compare column values, return diff array
     *
     * Pk column should be removed already.
     *
     * @param   string  $mode
     * @param   array   &$rowNew
     * @param   array   $columnArray
     * @param   array   &$rowOld
     * @return  array
     */
    protected function compareRowColumn(
        $mode,
        array &$rowNew,
        array $columnArray,
        array &$rowOld = null
    ) {
        $diff = [];

        foreach ((array)$columnArray as $column) {
            $valueNew = isset($rowNew[$column]) ? $rowNew[$column] : null;
            $valueOld = isset($rowOld[$column]) ? $rowOld[$column] : null;

            // Set useless column data to null. New value in DELETE mode is
            // useless, and old value in INSERT mode is useless too.
            if ('DELETE' == $mode) {
                $valueNew = null;
            }
            if ('INSERT' == $mode) {
                $valueOld = null;
            }

            // Skip equal value, they are not included in result diff array.
            // Change between null and non-null value (include '' and 0,
            // although they == null) will be kept. But 1 == '1' will be
            // skipped, so not using === and check equal only if both value
            // are not null.
            if ((is_null($valueNew) && is_null($valueOld)) ||
                (!is_null($valueNew) && !is_null($valueOld) &&
                    $valueNew == $valueOld)
            ) {
                continue;
            }

            $diff[$column] = [
                'new'   => $valueNew,
                'old'   => $valueOld,
            ];
        }

        return $diff;
    }




    /**
     * Get compare mode of a single row
     *
     * Mode: INSERT/UPDATE/DELETE
     *
     * Empty PK value are allowed, but null PK value will change mode flag and
     * ignore other non-null pk column values.
     *
     * @param   array   &$rowNew
     * @param   array   $pkArray
     * @param   array   &$rowOld
     * @return  string
     */
    protected function compareRowMode(
        array &$rowNew,
        array $pkArray,
        array &$rowOld = null
    ) {
        $nullPkInNew = false;
        $nullPkInOld = false;

        foreach ($pkArray as $pk) {
            if (is_null($rowNew[$pk])) {
                $nullPkInNew = true;
            }
            if (!isset($rowOld[$pk]) || is_null($rowOld[$pk])) {
                $nullPkInOld = true;
            }
        }

        if ($nullPkInNew && !$nullPkInOld) {
            $mode = 'DELETE';
        } elseif (!$nullPkInNew && $nullPkInOld) {
            $mode = 'INSERT';
        } elseif (!$nullPkInNew && !$nullPkInOld) {
            $mode = 'UPDATE';
        } else {
            throw new \Exception(
                'Pk in new and old array are all null'
            );
        }

        return $mode;
    }


    /**
     * Compare and extract PK values, return diff array
     *
     * Pk column are removed from new and old row columns.
     *
     * @param   array   &$rowNew
     * @param   array   $pkArray
     * @param   array   &$rowOld
     * @return  array
     */
    protected function compareRowPk(
        array &$rowNew,
        array $pkArray,
        array &$rowOld = null
    ) {
        $diff = [];

        foreach ($pkArray as $pk) {
            $diff[$pk] = [
                'new'   => $rowNew[$pk],
                'old'   => isset($rowOld[$pk]) ? $rowOld[$pk] : null,
            ];

            unset($rowNew[$pk]);
            unset($rowOld[$pk]);
        }

        return $diff;
    }


    /**
     * Compare different for a single table
     *
     * @param   string  $table
     * @param   array   $pkArray
     * @param   array   &$rowArrayNew
     * @param   array   &$dataOld
     * @return  array
     */
    protected function compareTable(
        $table,
        array $pkArray,
        array &$rowArrayNew,
        array &$dataOld = null
    ) {
        $diff = [];
        foreach ($rowArrayNew as $index => &$rowNew) {
            $columnArray = array_keys($rowNew);
            $pkValueArray = array_intersect_key(
                $rowNew,
                array_fill_keys($pkArray, null)
            );

            $rowOld = $this->prepareRowOld(
                $table,
                $index,
                $pkValueArray,
                $columnArray,
                $pkArray,
                $dataOld
            );

            $diffOfRow = $this->compareRow($rowNew, $pkArray, $rowOld);
            if (!empty($diffOfRow)) {
                $diff[] = $diffOfRow;
            }
        }
        unset($rowOld);

        return $diff;
    }


    /**
     * Compare and commit diff result
     *
     * If $dataNew is null, will use internal stored $diff.
     *
     * @param   array   $dataNew
     * @param   array   $dataOld
     * @return  DbDiff
     */
    public function execute(array $dataNew = null, array $dataOld = null)
    {
        if (!is_null($dataNew)) {
            $this->reset();
            $this->compare($dataNew, $dataOld);
        }

        if (!$this->isExecuted()) {
            $this->commit();

        } else {
            throw new \Exception(
                'Committed or rollbacked DbDiff can\'t execute again'
            );
        }

        return $this;
    }


    /**
     * Export to json string
     *
     * @return  string
     */
    public function export()
    {
        $json = $this->getUtilContainer()->getJson();

        return $json->encodeUnicode(
            [
                'rowCount'  => $this->rowCount,
                'executeStatus' => $this->executeStatus,
                'diff'          => $this->diff,
            ]
        );
    }


    /**
     * Generate commit sql array from diff result
     *
     * @return  array
     */
    protected function generateCommitSql()

    {
        $sqlArray = [];
        $db = $this->db;

        foreach ($this->diff as $table => $rowArray) {
            foreach ((array)$rowArray as $index => $row) {
                $sqlConfig = [];

                switch ($row['mode']) {
                    case 'INSERT':
                        $sqlConfig['INSERT'] = $table;

                        $columnArray = $row['pk'] + $row['column'];
                        foreach ($columnArray as $k => $v) {
                            $sqlConfig['VALUES'][$k] = $v['new'];
                        }

                        break;

                    case 'DELETE':
                        $sqlConfig['DELETE'] = $table;
                        // Limit row count to 1 for safety
                        $sqlConfig['LIMIT'] = 1;

                        foreach ($row['pk'] as $k => $v) {
                            $sqlConfig['WHERE'][] = $k . ' = ' .
                                $db->quoteValue($table, $k, $v['old']);
                        }

                        break;

                    case 'UPDATE':
                        $sqlConfig['UPDATE'] = $table;
                        // Limit row count to 1 for safety
                        $sqlConfig['LIMIT'] = 1;

                        foreach ($row['column'] as $k => $v) {
                            $sqlConfig['SET'][$k] = $v['new'];
                        }

                        foreach ($row['pk'] as $k => $v) {
                            $sqlConfig['WHERE'][] = $k . ' = ' .
                                $db->quoteValue($table, $k, $v['new']);
                        }

                        break;

                    default:
                        throw new \Exception("Invalid mode {$row['mode']}");
                }

                $sqlArray[] = $db->generateSql($sqlConfig);
            }
        }

        return $sqlArray;
    }


    /**
     * Generate rollback sql array from diff result
     *
     * @return  array
     */
    protected function generateRollbackSql()

    {
        $sqlArray = [];
        $db = $this->db;

        foreach ($this->diff as $table => $rowArray) {
            foreach ((array)$rowArray as $index => $row) {
                $sqlConfig = [];

                switch ($row['mode']) {
                    case 'INSERT':
                        $sqlConfig['DELETE'] = $table;
                        // Limit row count to 1 for safety
                        $sqlConfig['LIMIT'] = 1;

                        foreach ($row['pk'] as $k => $v) {
                            $sqlConfig['WHERE'][] = $k . ' = ' .
                                $db->quoteValue($table, $k, $v['new']);
                        }

                        break;

                    case 'DELETE':
                        $sqlConfig['INSERT'] = $table;

                        $columnArray = $row['pk'] + $row['column'];
                        foreach ($columnArray as $k => $v) {
                            $sqlConfig['VALUES'][$k] = $v['old'];
                        }

                        break;

                    case 'UPDATE':
                        $sqlConfig['UPDATE'] = $table;
                        // Limit row count to 1 for safety
                        $sqlConfig['LIMIT'] = 1;

                        foreach ($row['column'] as $k => $v) {
                            $sqlConfig['SET'][$k] = $v['old'];
                        }

                        foreach ($row['pk'] as $k => $v) {
                            $sqlConfig['WHERE'][] = $k . ' = ' .
                                $db->quoteValue($table, $k, $v['old']);
                        }

                        break;

                    default:
                        throw new \Exception("Invalid mode {$row['mode']}");
                }

                $sqlArray[] = $db->generateSql($sqlConfig);
            }
        }

        return $sqlArray;
    }


    /**
     * Getter of $diff
     *
     * @return  array
     */
    public function getDiff()
    {
        return $this->diff;
    }


    /**
     * Getter of $rowCount
     *
     * @return  int
     */
    public function getRowCount()
    {
        return $this->rowCount;
    }


    /**
     * Import from a json string
     *
     * Notice: Import empty string will report error.
     *
     * @param   string  $json
     * @return  DbDiff
     */
    public function import($json)
    {
        $this->reset();

        $info = $this->getUtilContainer()->getJson()
            ->decode($json, true);

        try {
            $this->rowCount = $info['rowCount'];
            $this->executeStatus = $info['executeStatus'];
            $this->diff = $info['diff'];

        } catch (\Exception $e) {
            throw new \Exception(
                'Invalid json string to import: ' . $e->getMessage()
            );
        }

        return $this;
    }


    /**
     * Is DbDiff executed/committed ?
     *
     * @return  bool
     */
    public function isCommitted()
    {
        return 100 == $this->executeStatus;
    }


    /**
     * Is DbDiff executed ?
     *
     * Return true when committed or rollbacked.
     *
     * @return  bool
     */
    public function isExecuted()
    {
        return 0 != $this->executeStatus;
    }


    /**
     * Is DbDiff rollbacked ?
     *
     * @return  bool
     */
    public function isRollbacked()
    {
        return -100 == $this->executeStatus;
    }


    /**
     * Prepare a single old row for compare
     *
     * If old row are not set, will query db using pk value from new row,
     * return null for not exists(INSERT mode).
     *
     * Also convert old row array to 2-dim.
     *
     * @param   string      $table
     * @param   int|string  $index
     * @param   array       $pkValueArray
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @param   array       $columnArray
     * @param   array       $pkArray
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @param   array       &$dataOld
     * @return  array
     */
    protected function prepareRowOld(
        $table,
        $index,
        array $keyValueArray,
        array $columnArray,
        array $keyArray,
        array &$dataOld = null
    ) {
        // Convert to 2-dim array
        if (isset($dataOld[$table]) && !is_array(current($dataOld[$table]))) {
            $dataOld[$table] = [$dataOld[$table]];
        }

        if (isset($dataOld[$table][$index])) {
            return $dataOld[$table][$index];
        }

        // Need query from db
        $rs = $this->db->getByKey(
            $table,
            $keyValueArray,
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $columnArray,
            $keyArray
        );

        // If row only have one column, convert back to array
        $rs = is_null($rs) ? $rs : (array)$rs;

        return $rs;
    }


    /**
     * Reset code, message and flag
     *
     * @return  DbDiff
     */
    public function reset()
    {
        $this->rowCount = 0;
        $this->executeStatus = 0;
        $this->diff = [];

        return $this;
    }


    /**
     * Rollback committed diff result
     *
     * @return  DbDiff
     */
    public function rollback()

    {
        if (empty($this->diff)) {
            throw new \Exception('No diff data');
        }

        if ($this->isRollbacked()) {
            throw new \Exception(
                'Rollbacked DbDiff can\'t rollback again'
            );
        }

        $sqlArray = $this->generateRollbackSql();

        $this->db->BeginTrans();
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }

        try {
            foreach ((array)$sqlArray as $sql) {
                $this->db->execute($sql);

                if (0 != $this->db->getErrorCode()) {
                    throw new \Exception($this->db->getErrorMessage());
                }
            }

            $this->db->CommitTrans();
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            // Rollback operate doesn't change $rowCount
            $this->executeStatus = -100;

        } catch (\Exception $e) {
            $this->db->RollbackTrans();
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }

            throw new \Exception($e->getMessage());
        }

        return $this;
    }
}

fwolf / fwlib

DbDiff F last analyzed 2019-05-09 15:53 UTC
