Edyan\Neuralyzer\Anonymizer\DB

Complexity

Total Complexity

45

Size/Duplication

Total Lines	396
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	7
Bugs	0	Features	1

12 Methods

Rating	Name	Duplication	Size	Complexity
A	getDbUtils()	0	3	1
A	processEntity()	0	39	5
A	setMode()	0	9	2
A	__construct()	0	6	1
B	generateFakeData()	0	29	7
A	doBatchInsert()	0	4	1
A	doBatchUpdate()	0	14	4
A	loadDataInBatch()	0	17	3
A	doInsertByQueries()	0	17	4
A	doUpdateByQueries()	0	24	5
B	updateData()	0	49	8
A	insertData()	0	22	4

<?php

declare(strict_types=1);

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

namespace Edyan\Neuralyzer\Anonymizer;

use Edyan\Neuralyzer\Exception\NeuralyzerConfigurationException;
use Edyan\Neuralyzer\Exception\NeuralyzerException;
use Edyan\Neuralyzer\Helper\DB\AbstractDBHelper;
use Edyan\Neuralyzer\Utils\CSVWriter;
use Edyan\Neuralyzer\Utils\DBUtils;
use Edyan\Neuralyzer\Utils\Expression;

/**
 * Implement AbstractAnonymizer for DB, to read and write data via Doctrine DBAL
 */
class DB extends AbstractAnonymizer
{
    /**
     * Various generic utils
     *
     * @var Expression
     */
    private $expression;

    /**
     * Various generic utils
     *
     * @var DBUtils
     */
    private $dbUtils;

    /**
     * Various generic utils
     *
     * @var AbstractDBHelper
     */
    private $dbHelper;

    /**
     * Primary Key
     *
     * @var string
     */
    private $priKey;

    /**
     * Define the way we update / insert data
     *
     * @var string
     */
    private $mode = 'queries';

    /**
     * Contains queries if returnRes is true
     *
     * @var array
     */
    private $queries = [];

    /**
     * File resource for the csv (batch mode)
     *
     * @var CSVWriter
     */
    private $csv;

    /**
     * Define available update modes
     *
     * @var array
     */
    private $updateMode = [
        'queries' => 'doUpdateByQueries',
        'batch' => 'doBatchUpdate',
    ];

    /**
     * Define available insert modes
     *
     * @var array
     */
    private $insertMode = [
        'queries' => 'doInsertByQueries',
        'batch' => 'doBatchInsert',
    ];

    /**
     * DB constructor.
     */
    public function __construct(Expression $expression, DBUtils $dbUtils)
    {
        $this->expression = $expression;
        $this->dbUtils = $dbUtils;
        $this->dbHelper = $this->dbUtils->getDBHelper();
        $this->dbHelper->registerCustomTypes();
    }

    /**
     * Returns the dependency
     */
    public function getDbUtils(): DBUtils
    {
        return $this->dbUtils;
    }

    /**
     * Set the mode for update / insert
     *
     * @throws NeuralyzerException
     */
    public function setMode(string $mode): DB
    {
        if (! in_array($mode, ['queries', 'batch'])) {
            throw new NeuralyzerException('Mode could be only queries or batch');
        }

        $this->mode = $mode;

        return $this;
    }

    /**
     * Process an entity by reading / writing to the DB
     *
     * @throws \Exception
     *
     * @return array
     */
    public function processEntity(string $entity, ?callable $callback = null): array
    {
        $this->dbUtils->assertTableExists($entity);

        $this->priKey = $this->dbUtils->getPrimaryKey($entity);
        $this->entityCols = $this->dbUtils->getTableCols($entity);
        $this->entity = $entity;

        $actionsOnThatEntity = $this->whatToDoWithEntity();
        $this->queries = [];

        // Prepare CSV
        if ($this->mode === 'batch') {
            $this->csv = new CSVWriter();
            $this->csv->setCsvControl('|', $this->dbHelper->getEnclosureForCSV());
        }

        // Wrap everything in a transaction
        $conn = $this->dbUtils->getConn();
        try {
            $conn->beginTransaction();

            if ($actionsOnThatEntity & self::UPDATE_TABLE) {
                $this->updateData($callback);
            }

            if ($actionsOnThatEntity & self::INSERT_TABLE) {
                $this->insertData($callback);
            }

            $conn->commit();
        } catch (\Exception $e) {
            $conn->rollBack();
            $conn->close(); // To avoid locks

            throw $e;
        }

        return $this->queries;
    }

    /**
     * Generate fake data for an entity and return it as an Array
     *
     * @return array
     *
     * @throws NeuralyzerConfigurationException
     */
    protected function generateFakeData(): array
    {
        $this->checkEntityIsInConfig();

        $colsInConfig = $this->configEntities[$this->entity]['cols'];
        $row = [];
        foreach ($colsInConfig as $colName => $colProps) {
            $this->checkColIsInEntity($colName);

            $data = \call_user_func_array(
                [$this->getFakerObject($this->entity, $colName, $colProps), $colProps['method']],
                $colProps['params']
            );

            if (! is_scalar($data)) {
                $msg = "You must use faker methods that generate strings: '{$colProps['method']}' forbidden";
                throw new NeuralyzerConfigurationException($msg);
            }

            $row[$colName] = is_string($data) ? trim($data) : $data;

            $colLength = $this->entityCols[$colName]['length'];
            // Cut the value if too long ...
            if (!empty($colLength) && is_string($row[$colName]) && \strlen($row[$colName]) > $colLength) {
                $row[$colName] = substr($row[$colName], 0, $colLength - 1);
            }
        }

        return $row;
    }

    /**
     * Update data of db table.
     */
    private function updateData(?callable $callback = null): void
    {
        $queryBuilder = $this->dbUtils->getConn()->createQueryBuilder();
        if ($this->limit === 0) {
            $this->setLimit($this->dbUtils->countResults($this->entity));
        }

        $this->expression->evaluateExpressions(
            $this->configEntities[$this->entity]['pre_actions']
        );

        $startAt = 0; // The first part of the limit (offset)
        $num = 0; // The number of rows updated
        $colsInConfig = $this->configEntities[$this->entity]['cols'];
        if (!empty($colsInConfig)) {
            while ($num < $this->limit) {
                $rows = $queryBuilder
                    ->select('*')->from($this->entity)
                    ->setFirstResult($startAt)->setMaxResults($this->batchSize)
                    ->orderBy($this->priKey)
                    ->execute();

                // 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)
                foreach ($rows as $row) {
                    // Call the right method according to the mode
                    $this->{$this->updateMode[$this->mode]}($row);

                    if ($callback !== null) {
                        $callback(++$num);
                    }
                    // Have to exit now as we have reached the max
                    if ($num >= $this->limit) {
                        break 2;
                    }
                }
                // Move the offset
                // Make sure the loop ends if we have nothing to process
                $num = $startAt += $this->batchSize;
            }
        }

        // Run a final method if defined
        if ($this->mode === 'batch') {
            $this->loadDataInBatch('update');
        }

        $this->expression->evaluateExpressions(
            $this->configEntities[$this->entity]['post_actions']
        );
    }

    /**
     * Execute the Update with Doctrine QueryBuilder
     *
     * @SuppressWarnings("unused") - Used dynamically
     *
     * @param  array $row Full row
     *
     * @throws NeuralyzerConfigurationException
     */
    private function doUpdateByQueries(array $row): void
    {
        $data = $this->generateFakeData();

        $queryBuilder = $this->dbUtils->getConn()->createQueryBuilder();
        $queryBuilder = $queryBuilder->update($this->entity);
        foreach ($data as $field => $value) {
            $value = empty($row[$field]) ?
                $this->dbUtils->getEmptyValue($this->entityCols[$field]['type']->getName()) :
                $value;

            $condition = $this->dbUtils->getCondition($field, $this->entityCols[$field]);
            $queryBuilder = $queryBuilder->set($field, $condition);
            $queryBuilder = $queryBuilder->setParameter(":${field}", $value);
        }
        $queryBuilder = $queryBuilder->where("{$this->priKey} = :{$this->priKey}");
        $queryBuilder = $queryBuilder->setParameter(":{$this->priKey}", $row[$this->priKey]);

        $this->returnRes === true ?
            array_push($this->queries, $this->dbUtils->getRawSQL($queryBuilder)) :
            null;

        if ($this->pretend === false) {
            $queryBuilder->execute();
        }
    }

    /**
     * Write the line required for a later LOAD DATA (or \copy)
     *
     * @SuppressWarnings("unused") - Used dynamically
     *
     * @param  array $row Full row
     *
     * @throws NeuralyzerConfigurationException
     */
    private function doBatchUpdate(array $row): void
    {
        $fakeData = $this->generateFakeData();
        $data = [];
        // Go trough all fields, and take a value by priority
        foreach (array_keys($this->entityCols) as $field) {
            // First take the fake data
            $data[$field] = $row[$field];
            if (! empty($row[$field]) && array_key_exists($field, $fakeData)) {
                $data[$field] = $fakeData[$field];
            }
        }

        $this->csv->write($data);
    }

    /**
     * Insert data into table
     */
    private function insertData(?callable $callback = null): void
    {
        $this->expression->evaluateExpressions(
            $this->configEntities[$this->entity]['pre_actions']
        );

        for ($rowNum = 1; $rowNum <= $this->limit; $rowNum++) {
            // Call the right method according to the mode
            $this->{$this->insertMode[$this->mode]}($rowNum);

            if (! is_null($callback)) {
                $callback($rowNum);
            }
        }

        // Run a final method if defined
        if ($this->mode === 'batch') {
            $this->loadDataInBatch('insert');
        }

        $this->expression->evaluateExpressions(
            $this->configEntities[$this->entity]['post_actions']
        );
    }

    /**
     * Execute an INSERT with Doctrine QueryBuilder
     *
     * @SuppressWarnings("unused") - Used dynamically
     */
    private function doInsertByQueries(): void
    {
        $data = $this->generateFakeData();

        $queryBuilder = $this->dbUtils->getConn()->createQueryBuilder();
        $queryBuilder = $queryBuilder->insert($this->entity);
        foreach ($data as $field => $value) {
            $queryBuilder = $queryBuilder->setValue($field, ":${field}");
            $queryBuilder = $queryBuilder->setParameter(":${field}", $value);
        }

        $this->returnRes === true ?
            array_push($this->queries, $this->dbUtils->getRawSQL($queryBuilder)) :
            null;

        if ($this->pretend === false) {
            $queryBuilder->execute();
        }
    }

    /**
     * Write the line required for a later LOAD DATA (or \copy)
     *
     * @SuppressWarnings("unused") - Used dynamically
     */
    private function doBatchInsert(): void
    {
        $data = $this->generateFakeData();
        $this->csv->write($data);
    }

    /**
     * If a file has been created for the batch mode, destroy it
     *
     * @SuppressWarnings("unused") - Used dynamically
     *
     * @param string $mode "update" or "insert"
     */
    private function loadDataInBatch(string $mode): void
    {
        $fields = array_keys($this->configEntities[$this->entity]['cols']);
        // Replace by all fields if update as we have to load everything
        if ($mode === 'update') {
            $fields = array_keys($this->entityCols);
        }

        // Load the data from the helper, only if pretend is false
        $filename = $this->csv->getPathName();
        $this->dbHelper->setPretend($this->pretend);
        $sql = $this->dbHelper->loadData($this->entity, $filename, $fields, $mode);

        $this->returnRes === true ? array_push($this->queries, $sql) : null;

        // Destroy the file
        unlink($this->csv->getRealPath());
    }
}