ExportFacade::dumpCreateTableOrView() - Code Metrics - lagdo/jaxon-dbadmin - Measure and Improve Code Quality continuously with Scrutinizer

ExportFacade::dumpCreateTableOrView() A
last analyzed 2025-12-22 05:57 UTC

↳ Parent: ExportFacade
Complexity

Conditions	4
Paths	4
Size

Total Lines	15
Code Lines	8
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	4
eloc	8
nc	4
nop	3
dl	0
loc	15
rs	10
c	0
b	0
f	0
<?php

namespace Lagdo\DbAdmin\Db\Driver\Facades;

use Lagdo\DbAdmin\Db\Page\DataDump;
use Lagdo\DbAdmin\Db\Page\TableExport;
use Lagdo\DbAdmin\Driver\Db\StatementInterface;
use Lagdo\DbAdmin\Driver\Entity\FieldType;
use Lagdo\DbAdmin\Driver\Entity\RoutineEntity;
use Lagdo\DbAdmin\Driver\Entity\RoutineInfoEntity;
use Lagdo\DbAdmin\Driver\Entity\TableEntity;
use Lagdo\DbAdmin\Driver\Entity\TableFieldEntity;
use Exception;

use function array_filter;
use function array_keys;
use function array_map;
use function count;
use function implode;
use function is_numeric;
use function ksort;
use function preg_match;
use function rtrim;
use function str_replace;
use function trim;

/**
 * Facade to export functions
 */
class ExportFacade extends AbstractFacade
{
    /**
     * The databases to dump
     *
     * @var array
     */
    private $databases;


    /**
     * The tables to dump
     *
     * @var array
     */
    private $tables;


    /**
     * The queries generated by the dump
     *
     * @var array
     */
    private $queries = [];

    /**
     * The dump options
     *
     * @var array
     */
    private $options;

    /**
     * @return TableExport
     */
    private function export(): TableExport
    {
        return new TableExport($this->page, $this->driver, $this->utils);
        return new TableExport($this->page, /** @scrutinizer ignore-type */ $this->driver, $this->utils);
    }

    /**
     * Print CSV row
     *
     * @param array  $row
     *
     * @return void
     */
    private function dumpCsv(array $row)
    {
        // From functions.inc.php
        foreach ($row as $key => $val) {
            if (preg_match('~["\n,;\t]|^0|\.\d*0$~', $val ?? '') || $val === '') {
                $row[$key] = '"' . str_replace('"', '""', $val) . '"';
            }
        }
        $separator = match($this->options['format']) {
            'csv' => ',',
            'tsv' => "\t",
            default => ';',
        };
        $this->queries[] = implode($separator, $row);
    }

    /**
     * Convert a value to string
     *
     * @param mixed  $value
     * @param TableFieldEntity $field
     *
     * @return string
     */
    private function convertToString($value, TableFieldEntity $field): string
    {
        // From functions.inc.php
        if ($value === null) {
            return 'NULL';
        }

        if (!preg_match($this->driver->numberRegex(), $field->type) ||
        if (!preg_match($this->driver->/** @scrutinizer ignore-call */ numberRegex(), $field->type) ||
            preg_match('~\[~', $field->fullType) && is_numeric($value)) {
            $value = $this->driver->quote(($value === false ? 0 : $value));
        }
        return $this->driver->unconvertField($field, $value);
    }

    /**
     * @param string $table
     *
     * @return void
     */
    private function dumpTruncateQuery(string $table)
    {
        if ($this->options['format'] === 'sql' &&
            $this->options['data_style'] === 'TRUNCATE+INSERT') {
            $this->queries[] = $this->driver->getTruncateTableQuery($table) . ";\n";
        }
    }

    /**
     * @param DataDump $dump
     * @param array $row
     * @param StatementInterface $statement
     *
     * @return array
     */
    private function getDataRowKeys(DataDump $dump, array $row, StatementInterface $statement): array
    {
        $values = [];
        $keys = [];
        // For is preferred to foreach because the values are not used.
        // foreach ($row as $val) {
        // }
        $rowCount = count($row);
        for ($i = 0; $i < $rowCount; $i++) {
            $field = $statement->fetchField();
            $keys[] = $field->name();
            $key = $this->driver->escapeId($field->name());
            $values[] = "$key = VALUES($key)";
        }
        $dump->suffix = $this->options['data_style'] !== 'INSERT+UPDATE' ? ';' :
            "\nON DUPLICATE KEY UPDATE " . implode(', ', $values) . ';';

        return $keys;
    }

    /**
     * @param DataDump $dump
     * @param array $fields
     * @param array $row
     * @param array $keys
     *
     * @return void
     */
    private function dumpRow(DataDump $dump, array $fields, array $row, array $keys)
    {
        if ($this->options['format'] !== 'sql') {
            if ($this->options['data_style'] === 'table') {
                $this->dumpCsv($keys);
                $this->options['data_style'] = 'INSERT';
            }
            $this->dumpCsv($row);
            return;
        }

        if ($dump->insert === '') {
            $dump->insert = 'INSERT INTO ' . $this->driver->escapeTableName($dump->table) . ' (' .
                implode(', ', array_map(function ($key) {
                    return $this->driver->escapeId($key);
                }, $keys)) . ') VALUES';
        }
        foreach ($row as $key => $val) {
            $field = $fields[$key];
            $row[$key] = $this->convertToString($val, $field);
        }

        $dump->addRow($row);
        if ($dump->limitExceeded()) {
            $this->queries[] = $dump->makeQuery();
        }
    }

    /**
     * @param DataDump $dump
     * @param StatementInterface $statement
     *
     * @return void
     */
    private function dumpRows(DataDump $dump, StatementInterface $statement)
    {
        $fields = $this->options['format'] !== 'sql' ? [] : $this->driver->fields($dump->table);
        $keys = [];
        $fetchFunction = $dump->table !== '' ?
            fn($statement) => $statement->fetchAssoc() :
            fn($statement) => $statement->fetchRow();
        while ($row = $fetchFunction($statement)) {
            if (empty($keys)) {
                $keys = $this->getDataRowKeys($dump, $row, $statement);
            }
            $this->dumpRow($dump, $fields, $row, $keys);
        }
        if (count($dump->dataRows) > 0) {
            $this->queries[] = $dump->makeQuery();
        }
    }

    /** Export table data
     *
     * @param string $table
     *
     * @return void
     */
    private function dumpTableData(string $table)
    {
        if (!$this->options['data_style']) {
            return;
        }
        $fields = $this->driver->fields($table);
        $query = 'SELECT *' . $this->driver->convertFields($fields, $fields) .
            ' FROM ' . $this->driver->escapeTableName($table);
        // 1 - MYSQLI_USE_RESULT //! enum and set as numbers
        $statement = $this->driver->execute($query);
        if (!$statement) {
            if ($this->options['format'] === 'sql') {
                $this->queries[] = '-- ' . str_replace("\n", ' ', $this->driver->error()) . "\n";
            }
            return;
        }

        $maxRowSize = ($this->driver->jush() === 'sqlite' ? 0 : 1048576); // default, minimum is 1024
        $separator = $maxRowSize > 0 ? "\n" : ' ';
        $dump = new DataDump($table, $maxRowSize, $separator);

        $this->dumpTruncateQuery($table);
        $this->dumpRows($dump, $statement);
        $this->dumpRows($dump, /** @scrutinizer ignore-type */ $statement);
    }

    /**
     * @param string $table
     * @param string $style
     * @param int $tableType
     *
     * @return string
     */
    private function getCreateQuery(string $table, string $style, int $tableType): string
    {
        if ($tableType !== 2) {
            return $this->driver->getCreateTableQuery($table,
                $this->options['autoIncrement'], $style);
        }

        $fields = [];
        foreach ($this->driver->fields($table) as $name => $field) {
            $fields[] = $this->driver->escapeId($name) . ' ' . $field->fullType;
        }
        return 'CREATE TABLE ' . $this->driver->escapeTableName($table) .
            ' (' . implode(', ', $fields) . ')';
    }

    /**
     * Export table structure
     *
     * @param string $table
     * @param string $style
     * @param int    $tableType       0 table, 1 view, 2 temporary view table
     *
     * @return void
     */
    private function addCreateQuery(string $table, string $style, int $tableType): void
    {
        $query = $this->getCreateQuery($table, $style, $tableType);
        if (!$query) {
            return;
        }

        $this->driver->setUtf8mb4($query);
        if ($style === 'DROP+CREATE' || $tableType === 1) {
            $this->queries[] = 'DROP ' . ($tableType === 2 ? 'VIEW' : 'TABLE') .
                ' IF EXISTS ' . $this->driver->escapeTableName($table) . ';';
        }
        if ($tableType === 1) {
            $query = $this->driver->removeDefiner($query);
        }
        $this->queries[] = "$query;\n";
    }

    /**
     * Export table structure
     *
     * @param string $table
     * @param string $style
     * @param int    $tableType       0 table, 1 view, 2 temporary view table
     *
     * @return void
     */
    private function dumpCreateTableOrView(string $table, string $style, int $tableType = 0): void
    {
        // From adminer.inc.php
        if ($this->options['format'] !== 'sql') {
            $this->queries[] = "\xef\xbb\xbf"; // UTF-8 byte order mark
            if ($style) {
                $this->dumpCsv(array_keys($this->driver->fields($table)));
            }
            return;
        }
        if (!$style) {
            return;
        }

        $this->addCreateQuery($table, $style, $tableType);
    }

    /**
     * @param string $table
     *
     * @return void
     */
    private function dumpTableTriggers(string $table): void
    {
        if (($triggers = $this->driver->getCreateTriggerQuery($table)) !== '') {
            $this->queries[] = '';
            $this->queries[] = 'DELIMITER ;;';
            $this->queries[] = $triggers;
            $this->queries[] = 'DELIMITER ;';
        }
    }

    /**
     * @param TableEntity $tableStatus
     * @param bool $dumpTable
     * @param bool $dumpData
     *
     * @return void
     */
    private function dumpTable(TableEntity $tableStatus, bool $dumpTable, bool $dumpData): void
    {
        $style = $dumpTable ? $this->options['table_style'] : '';
        $tableType = $this->driver->isView($tableStatus) ? 2 : 1;
        $this->dumpCreateTableOrView($tableStatus->name, $style, $tableType);
        if ($dumpData) {
            $this->dumpTableData($tableStatus->name);
        }
        if ($this->options['to_sql'] && $this->options['triggers'] && $dumpTable) {
            $this->dumpTableTriggers($tableStatus->name);
        }
    }

    /**
     * @param array<TableEntity> $tableStatuses
     * @param array $tableOptions
     *
     * @return void
     */
    private function dumpTables(array $tableStatuses, array $tableOptions): void
    {
        foreach ($tableStatuses as $status) {
            $this->queries[] = '';
            $options = $tableOptions[$status->name] ?? $tableOptions['*'];
            $this->dumpTable($status, $options['table'], $options['data']);
        }
        if ($this->driver->jush() !== 'pgsql') {
            return;
        }

        // Add FKs after creating tables (except in MySQL which uses SET FOREIGN_KEY_CHECKS=0)
        $this->queries[] = '';
        $tables = array_filter($tableStatuses,
            fn($status) => !$this->driver->isView($status));
        foreach ($tables as $status) {
            $queries = $this->driver->getForeignKeysQueries($status);
            foreach ($queries as $query) {
                $this->queries[] = $query;
            }
            if (count($queries) > 0) {
                $this->queries[] = '';
            }
        }
    }

    /**
     * @param array $tableStatuses
     *
     * @return void
     */
    private function dumpViews(array $tableStatuses)
    {
        $views = array_filter($tableStatuses,
            fn($status) => $this->driver->isView($status));
        foreach ($views as $view) {
            $this->dumpCreateTableOrView($view->name, $this->options['table_style'], 1);
        }
    }

    /**
     * Get data for export
     *
     * @param string $database      The database name
     * @param string $table
     *
     * @return array
     */
    public function getExportOptions(string $database, string $table = ''): array
    {
        $export = $this->export();
        return $database === '' ? [
            'databases' => $export->getDatabases(),
            'options' => $export->getBaseOptions($database, $table),
            'prefixes' => [],
        ] : [
            'tables' => $export->getDbTables(),
            'options' => $export->getBaseOptions($database, $table),
            'prefixes' => [],
        ];
    }

    /**
     * @return array
     */
    public function getSelectValues(): array
    {
        $export = $this->export();
        return [
            'output' => array_keys($export->getSelectOutputValues()),
            'format' => array_keys($export->getSelectFormatValues()),
            'db_style' => $export->getSelectDatabaseValues(),
            'table_style' => $export->getSelectTableValues(),
            'data_style' => $export->getSelectDataValues(),
        ];
    }

    /**
     * @param array<FieldType> $params
     *
     * @return string
     */
    private function getRoutineParams(array $params): string
    {
        // From dump.inc.php create_routine()
        $params = array_filter($params, fn($param) => $param->name !== '');
        ksort($params); // enforce params order
        $regex = "~^(" . $this->driver->inout() . ")\$~";

        $params = array_map(function($param) use($regex) {
            $inout = preg_match($regex, $param->inout) ? "{$param->inout} " : '';
            return $inout . $this->driver->escapeId($param->name) .
                $this->driver->processType($param, 'CHARACTER SET');
        },$params);
        return implode(', ', $params);
    }

    /**
     * Generate SQL query for creating routine
     *
     * @param RoutineEntity $routine
     * @param RoutineInfoEntity $routineInfo
     *
     * @return string
     */
    private function getRoutineQuery(RoutineEntity $routine, RoutineInfoEntity $routineInfo): string
    {
        // From dump.inc.php create_routine()
        $routineName = $this->driver->escapeId(trim($routine->name));
        $routineParams = $this->getRoutineParams($routineInfo->params);
        $routineReturns = $routine->type !== 'FUNCTION' ? '' :
            ' RETURNS' . $this->driver->processType($routineInfo->return, 'CHARACTER SET');
            ' RETURNS' . $this->driver->processType(/** @scrutinizer ignore-type */ $routineInfo->return, 'CHARACTER SET');
        $routineLanguage = $routineInfo->language ? " LANGUAGE {$routineInfo->language}" : '';
        $definition = rtrim($routineInfo->definition, ';');
        $routineDefinition = $this->driver->jush() !== 'pgsql' ? "\n$definition;" :
            ' AS ' . $this->driver->quote($definition);

        return "CREATE {$routine->type} $routineName ($routineParams)" .
            "{$routineReturns}{$routineLanguage}{$routineDefinition};";
    }

    /**
     * Dump types in the connected database
     *
     * @return void
     */
    private function dumpTypes(): void
    {
        if (!$this->options['types']) {
            return;
        }

        // From dump.inc.php
        $style = $this->options['db_style'];
        foreach ($this->driver->userTypes(true) as $type) {
            $this->queries[] = ''; // Empty line
            if (count($type->enums) === 0) {
                //! https://github.com/postgres/postgres/blob/REL_17_4/src/bin/pg_dump/pg_dump.c#L10846
                $this->queries[] = "-- Could not export type {$type->name}";
                continue;
            }

            $typeName = $this->driver->escapeId($type->name);
            if ($style !== 'DROP+CREATE') {
                $this->queries[] = "DROP TYPE IF EXISTS $typeName;;";
            }
            $enums = implode("', '", $type->enums);
            $this->queries[] = "CREATE TYPE $typeName AS ENUM ('$enums');";
        }
    }

    /**
     * Dump routines in the connected database
     *
     * @return void
     */
    private function dumpRoutines(): void
    {
        if (!$this->options['routines']) {
            return;
        }

        // From dump.inc.php
        $style = $this->options['db_style'];
        foreach ($this->driver->routines() as $routine) {
            $routineName = $this->driver->escapeId(trim($routine->name));
            $routineInfo = $this->driver->routine($routine->specificName, $routine->type);
            if ($routineInfo === null) {
                continue;
            }

            $create = $this->getRoutineQuery($routine, $routineInfo);
            $this->driver->setUtf8mb4($create);
            $this->queries[] = ''; // Empty line
            if ($style !== 'DROP+CREATE') {
                $this->queries[] = "DROP {$routine->type} IF EXISTS $routineName;;";
            }
            $this->queries[] = $create;
        }
    }

    /**
     * Dump events in the connected database
     *
     * @return void
     */
    private function dumpEvents(): void
    {
        if (!$this->options['events']) {
            return;
        }

        // From dump.inc.php
        $style = $this->options['db_style'];
        foreach ($this->driver->rows('SHOW EVENTS') as $row) {
            $sql = 'SHOW CREATE EVENT ' . $this->driver->escapeId($row['Name']);
            $create = $this->driver->removeDefiner($this->driver->result($sql, 3));
            $this->driver->setUtf8mb4($create);
            $this->queries[] = ''; // Empty line
            if ($style !== 'DROP+CREATE') {
                $this->queries[] = 'DROP EVENT IF EXISTS ' . $this->driver->escapeId($row['Name']) . ';;';
            }
            $this->queries[] = "$create;;\n";
        }
    }

    /**
     * @param string $database
     *
     * @return void
     */
    private function dumpUseDatabaseQuery(string $database): void
    {
        $style = $this->options['db_style'];
        if ($style === '' || !preg_match('~sql~', $this->options['format'])) {
            return;
        }

        $this->queries[] = $this->driver->getUseDatabaseQuery($database, $style);
    }

    /**
     * @param string $database
     * @param array $tableOptions
     *
     * @return void
     */
    private function dumpDatabase(string $database, array $tableOptions): void
    {
        $this->driver->openConnection($database); // New connection
        $this->dumpUseDatabaseQuery($database);

        if ($this->options['to_sql']) {
            $this->dumpTypes();
            $this->dumpRoutines();
            $this->dumpEvents();
        }

        if (!$this->options['table_style'] && !$this->options['data_style']) {
            return;
        }

        $statuses = array_filter($this->driver->tableStatuses(true), fn($status) =>
            isset($tableOptions['*']) || isset($tableOptions[$status->name]));
        $this->dumpTables($statuses, $tableOptions);
        // Dump the views after all the tables
        $this->dumpViews($statuses);
    }

    /**
     * @return array
     */
    private function getDatabaseExportHeaders(): array
    {
        $headers = [
            'version' => $this->driver->version(),
            'driver' => $this->driver->name(),
            'server' => str_replace("\n", ' ', $this->driver->serverInfo()),
            'sql' => false,
            'data_style' => false,
        ];
        if ($this->driver->jush() === 'sql') {
            $headers['sql'] = true;
            if (isset($this->options['data_style'])) {
                $headers['data_style'] = true;
            }
            // Set some options in database server
            $this->driver->execute("SET time_zone = '+00:00'");
            $this->driver->execute("SET sql_mode = ''");
        }
        return $headers;
    }

    /**
     * Export databases
     *
     * @param array  $databases     The databases to dump
     * @param array  $options       The export options
     *
     * @return array|string
     */
    public function exportDatabases(array $databases, array $options): array|string
    {
        // From dump.inc.php
        // $tables = array_flip($options['tables']) + array_flip($options['data']);
        // $ext = dump_headers((count($tables) == 1 ? key($tables) : DB), (DB == '' || count($tables) > 1));
        $this->options = $options;
        // Export to SQL format (renamed from is_sql to to_sql).
        $this->options['to_sql'] = preg_match('~sql~', $options['format']) === 1;

        $headers = !$this->options['to_sql'] ? null : $this->getDatabaseExportHeaders();

        foreach ($databases as $database => $tables) {
            try {
                $this->dumpDatabase($database, $tables);
            }
            catch (Exception $e) {
                return $e->getMessage();
            }
        }

        if ($this->options['to_sql']) {
            $this->queries[] = '-- ' . $this->driver->result('SELECT NOW()');
        }

        return [
            'headers' => $headers,
            'queries' => $this->queries,
        ];
    }
}

lagdo / jaxon-dbadmin

ExportFacade::dumpCreateTableOrView() A last analyzed 2025-12-22 05:57 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

ExportFacade::dumpCreateTableOrView() A
last analyzed 2025-12-22 05:57 UTC
