DB::__construct() - Code Metrics - Inspection of "Don't block if any error happens, just stop the an..." - edyan/neuralyzer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 3a5c6d...7f7360 )

by Emmanuel

created 2017-08-22 16:06 UTC

DB::__construct() A

↳ Parent: DB

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	5
ccs	4
cts	4
cp	1
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	3
nc	1
nop	1
crap	1

<?php
/**
 * neuralyzer : Data Anonymization Library and CLI Tool
 *
 * PHP Version 7.0
 *
 * @author Emmanuel Dyan
 * @author Rémi Sauvat
 * @copyright 2017 Emmanuel Dyan
 *
 * @package edyan/neuralyzer
 *
 * @license GNU General Public License v2.0
 *
 * @link https://github.com/edyan/neuralyzer
 */

namespace Inet\Neuralyzer\Anonymizer;

use Inet\Neuralyzer\Exception\NeuralizerException;

/**
 * DB Anonymizer
 */
class DB extends AbstractAnonymizer
{
    /**
     * The PDO connection
     *
     * @var \PDO
     */
    private $pdo;

    /**
     * Prepared statement is stored for the update, to make the queries faster
     *
     * @var \PDOStatement
     */
    private $preparedStmt;

    /**
     * Constructor
     *
     * @param \PDO $pdo
     */
    public function __construct(\PDO $pdo)
    {
        $this->pdo = $pdo;
        $this->pdo->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
    }

    /**
     * Process an entity by reading / writing to the DB
     *
     * @param string        $table
     * @param callable|null $callback
     * @param bool          $pretend
     * @param bool          $returnResult
     *
     * @return void|array
     */
    public function processEntity(
        string $table,
        callable $callback = null,
        bool $pretend = true,
        bool $returnResult = false
    ) {
        $queries = [];
        $actionsOnThatEntity = $this->whatToDoWithEntity($table);

        if ($actionsOnThatEntity & self::TRUNCATE_TABLE) {
            $where = $this->getWhereConditionInConfig($table);
            $query = $this->runDelete($table, $where, $pretend);
            ($returnResult === true ? array_push($queries, $query) : '');
        }

        if ($actionsOnThatEntity & self::UPDATE_TABLE) {
            // I need to read line by line if I have to update the table
            // to make sure I do update by update (slower but no other choice for now)
            $i = 0;
            $this->preparedStmt = null;

            $key = $this->getPrimaryKey($table);
            $res = $this->pdo->query("SELECT $key FROM $table");
            $res->setFetchMode(\PDO::FETCH_ASSOC);

            $this->pdo->beginTransaction();

            while ($row = $res->fetch()) {
                $val = $row[$key];
                $data = $this->generateFakeData($table);

                if ($pretend === false) {
                    $this->runUpdate($table, $data, $key, $val);
                }
                ($returnResult === true ? array_push($queries, $this->buildUpdateSQL($table, $data, "$key = '$val'")) : '');

                if (!is_null($callback)) {
                    $callback(++$i);
                }
            }

            // Commit, even if I am in pretend (that will do ... nothing)
            $this->pdo->commit();
        }

        return $queries;
    }

    /**
     * Identify the primary key for a table
     *
     * @param string $table
     *
     * @return string Field's name
     */
    protected function getPrimaryKey(string $table)
    {
        try {
            $res = $this->pdo->query("SHOW COLUMNS FROM $table WHERE `Key` = 'Pri'");
        } catch (\Exception $e) {
            throw new NeuralizerException('Query Error : ' . $e->getMessage());
        }

        $primary = $res->fetchAll(\PDO::FETCH_COLUMN);
        // Didn't find a primary key !
        if (empty($primary)) {
            throw new NeuralizerException("Can't find a primary key for '$table'");
        }

        return $primary[0];
    }

    /**
     * Execute the Update with PDO
     *
     * @param string $table      Name of the table
     * @param array  $data       Array of fields => value to update the table
     * @param string $primaryKey
     * @param string $val        Primary Key's Value
     */
    private function runUpdate(string $table, array $data, string $primaryKey, $val)
    {
        if (is_null($this->preparedStmt)) {
            $this->prepareStmt($table, $primaryKey, array_keys($data));
        }

        $values = [":$primaryKey" => $val];
        foreach ($data as $field => $value) {
            $values[":$field"] = $value;
        }

        try {
            $this->preparedStmt->execute($values);
        } catch (\PDOException $e) {
            $this->pdo->rollback();
            throw new NeuralizerException("Problem anonymizing $table (" . $e->getMessage() . ')');
        }
    }

    /**
     * Prepare the statement if asked
     *
     * @param string $table
     * @param string $primaryKey
     * @param array  $fieldNames
     *
     * @return \PDOStatement
     */
    private function prepareStmt(string $table, string $primaryKey, array $fieldNames)
    {
        $fields = [];
        foreach ($fieldNames as $field) {
            $fields[] = "$field = IF($field IS NOT NULL, :$field, NULL)";
        }
        $sql = "UPDATE $table SET " . implode(', ', $fields) . " WHERE $primaryKey = :$primaryKey";
        $this->preparedStmt = $this->pdo->prepare($sql);
    }

    /**
     * Execute the Delete with PDO
     *
     * @param string $table
     * @param string $where
     * @param bool   $pretend
     *
     * @return string
     */
    private function runDelete(string $table, string $where, bool $pretend): string
    {
        $where = empty($where) ? '' : " WHERE $where";
        $sql = "DELETE FROM {$table}{$where}";

        if ($pretend === true) {
            return $sql;
        }

        try {
            $this->pdo->query($sql);
        } catch (\Exception $e) {
            throw new NeuralizerException('Query DELETE Error (' . $e->getMessage() . ')');
        }

        return $sql;
    }

    /**
     * Build the SQL just for debug
     *
     * @param string $table
     * @param array  $data
     * @param string $where
     *
     * @return string
     */
    private function buildUpdateSQL(string $table, array $data, string $where): string
    {
        $fieldsVals = [];
        foreach ($data as $field => $value) {
            $fieldsVals[] = "$field = IF($field IS NOT NULL, '" . $this->pdo->quote($value) . "', NULL)";
        }

        $sql = "UPDATE $table SET " . implode(', ', $fieldsVals) . " WHERE $where";

        return $sql;
    }
}


1		<?php
2		/**
3		* neuralyzer : Data Anonymization Library and CLI Tool
4		*
5		* PHP Version 7.0
6		*
7		* @author Emmanuel Dyan
8		* @author Rémi Sauvat
9		* @copyright 2017 Emmanuel Dyan
10		*
11		* @package edyan/neuralyzer
12		*
13		* @license GNU General Public License v2.0
14		*
15		* @link https://github.com/edyan/neuralyzer
16		*/
17
18		namespace Inet\Neuralyzer\Anonymizer;
19
20		use Inet\Neuralyzer\Exception\NeuralizerException;
21
22		/**
23		* DB Anonymizer
24		*/
25		class DB extends AbstractAnonymizer
26		{
27		/**
28		* The PDO connection
29		*
30		* @var \PDO
31		*/
32		private $pdo;
33
34		/**
35		* Prepared statement is stored for the update, to make the queries faster
36		*
37		* @var \PDOStatement
38		*/
39		private $preparedStmt;
40
41		/**
42		* Constructor
43		*
44		* @param \PDO $pdo
45		*/
46	2	public function __construct(\PDO $pdo)
47		{
48	2	$this->pdo = $pdo;
49	2	$this->pdo->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
50	2	}
51
52		/**
53		* Process an entity by reading / writing to the DB
54		*
55		* @param string $table
56		* @param callable\|null $callback
57		* @param bool $pretend
58		* @param bool $returnResult
59		*
60		* @return void\|array
61		*/
62	1	public function processEntity(
63		string $table,
64		callable $callback = null,
65		bool $pretend = true,
66		bool $returnResult = false
67		) {
68	1	$queries = [];
69	1	$actionsOnThatEntity = $this->whatToDoWithEntity($table);
70
71	1	if ($actionsOnThatEntity & self::TRUNCATE_TABLE) {
72		$where = $this->getWhereConditionInConfig($table);
73		$query = $this->runDelete($table, $where, $pretend);
74		($returnResult === true ? array_push($queries, $query) : '');
75		}
76
77	1	if ($actionsOnThatEntity & self::UPDATE_TABLE) {
78		// I need to read line by line if I have to update the table
79		// to make sure I do update by update (slower but no other choice for now)
80	1	$i = 0;
81	1	$this->preparedStmt = null;
82
83	1	$key = $this->getPrimaryKey($table);
84	1	$res = $this->pdo->query("SELECT $key FROM $table");
85	1	$res->setFetchMode(\PDO::FETCH_ASSOC);
86
87	1	$this->pdo->beginTransaction();
88
89	1	while ($row = $res->fetch()) {
90	1	$val = $row[$key];
91	1	$data = $this->generateFakeData($table);
92
93	1	if ($pretend === false) {
94	1	$this->runUpdate($table, $data, $key, $val);
95		}
96	1	($returnResult === true ? array_push($queries, $this->buildUpdateSQL($table, $data, "$key = '$val'")) : '');
97
98	1	if (!is_null($callback)) {
99	1	$callback(++$i);
100		}
101		}
102
103		// Commit, even if I am in pretend (that will do ... nothing)
104	1	$this->pdo->commit();
105		}
106
107	1	return $queries;
108		}
109
110		/**
111		* Identify the primary key for a table
112		*
113		* @param string $table
114		*
115		* @return string Field's name
116		*/
117	1	protected function getPrimaryKey(string $table)
118		{
119		try {
120	1	$res = $this->pdo->query("SHOW COLUMNS FROM $table WHERE `Key` = 'Pri'");
121		} catch (\Exception $e) {
122		throw new NeuralizerException('Query Error : ' . $e->getMessage());
123		}
124
125	1	$primary = $res->fetchAll(\PDO::FETCH_COLUMN);
126		// Didn't find a primary key !
127	1	if (empty($primary)) {
128		throw new NeuralizerException("Can't find a primary key for '$table'");
129		}
130
131	1	return $primary[0];
132		}
133
134		/**
135		* Execute the Update with PDO
136		*
137		* @param string $table Name of the table
138		* @param array $data Array of fields => value to update the table
139		* @param string $primaryKey
140		* @param string $val Primary Key's Value
141		*/
142	1	private function runUpdate(string $table, array $data, string $primaryKey, $val)
143		{
144	1	if (is_null($this->preparedStmt)) {
145	1	$this->prepareStmt($table, $primaryKey, array_keys($data));
146		}
147
148	1	$values = [":$primaryKey" => $val];
149	1	foreach ($data as $field => $value) {
150	1	$values[":$field"] = $value;
151		}
152
153		try {
154	1	$this->preparedStmt->execute($values);
155		} catch (\PDOException $e) {
156		$this->pdo->rollback();
157		throw new NeuralizerException("Problem anonymizing $table (" . $e->getMessage() . ')');
158		}
159	1	}
160
161		/**
162		* Prepare the statement if asked
163		*
164		* @param string $table
165		* @param string $primaryKey
166		* @param array $fieldNames
167		*
168		* @return \PDOStatement
169		*/
170	1	private function prepareStmt(string $table, string $primaryKey, array $fieldNames)
171		{
172	1	$fields = [];
173	1	foreach ($fieldNames as $field) {
174	1	$fields[] = "$field = IF($field IS NOT NULL, :$field, NULL)";
175		}
176	1	$sql = "UPDATE $table SET " . implode(', ', $fields) . " WHERE $primaryKey = :$primaryKey";
177	1	$this->preparedStmt = $this->pdo->prepare($sql);
178	1	}
179
180		/**
181		* Execute the Delete with PDO
182		*
183		* @param string $table
184		* @param string $where
185		* @param bool $pretend
186		*
187		* @return string
188		*/
189		private function runDelete(string $table, string $where, bool $pretend): string
190		{
191		$where = empty($where) ? '' : " WHERE $where";
192		$sql = "DELETE FROM {$table}{$where}";
193
194		if ($pretend === true) {
195		return $sql;
196		}
197
198		try {
199		$this->pdo->query($sql);
200		} catch (\Exception $e) {
201		throw new NeuralizerException('Query DELETE Error (' . $e->getMessage() . ')');
202		}
203
204		return $sql;
205		}
206
207		/**
208		* Build the SQL just for debug
209		*
210		* @param string $table
211		* @param array $data
212		* @param string $where
213		*
214		* @return string
215		*/
216		private function buildUpdateSQL(string $table, array $data, string $where): string
217		{
218		$fieldsVals = [];
219		foreach ($data as $field => $value) {
220		$fieldsVals[] = "$field = IF($field IS NOT NULL, '" . $this->pdo->quote($value) . "', NULL)";
221		}
222
223		$sql = "UPDATE $table SET " . implode(', ', $fieldsVals) . " WHERE $where";
224
225		return $sql;
226		}
227		}
228

edyan / neuralyzer

Push — master ( 3a5c6d...7f7360 )

DB::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like