PhpMyAdmin\Dbal\DatabaseInterface::getTablesFull()

Complexity

Conditions	53
Paths	> 20000

Size

Total Lines	245
Code Lines	120

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	54
CRAP Score	567.7504

Importance

Changes

0

<?php
    public function getTablesFull(
        string $database,
        string|array $table = '',
        bool $tableIsGroup = false,
        int $limitOffset = 0,
        bool|int $limitCount = false,
        string $sortBy = 'Name',
        string $sortOrder = 'ASC',
        string|null $tableType = null,
        ConnectionType $connectionType = ConnectionType::User,
    ): array {
        if ($limitCount === true) {
            $limitCount = $this->config->settings['MaxTableList'];
        }

        $tables = [];
        $pagingApplied = false;

        if ($limitCount && is_array($table) && $sortBy === 'Name') {
            if ($sortOrder === 'DESC') {
                $table = array_reverse($table);
            }

            $table = array_slice($table, $limitOffset, $limitCount);
            $pagingApplied = true;
        }

        if (! $this->config->selectedServer['DisableIS']) {
            $sqlWhereTable = '';
            if ($table !== [] && $table !== '') {
                if (is_array($table)) {
                    $sqlWhereTable = QueryGenerator::getTableNameConditionForMultiple(
                        array_map($this->quoteString(...), $table),
                    );
                } else {
                    $sqlWhereTable = QueryGenerator::getTableNameCondition(
                        $this->quoteString($tableIsGroup ? $this->escapeMysqlWildcards($table) : $table),
                        $tableIsGroup,
                    );
                }
            }

            $sqlWhereTable .= QueryGenerator::getTableTypeCondition($tableType);

            // for PMA bc:
            // `SCHEMA_FIELD_NAME` AS `SHOW_TABLE_STATUS_FIELD_NAME`
            //
            // on non-Windows servers,
            // added BINARY in the WHERE clause to force a case sensitive
            // comparison (if we are looking for the db Aa we don't want
            // to find the db aa)

            $sql = QueryGenerator::getSqlForTablesFull($this->quoteString($database), $sqlWhereTable);

            // Sort the tables
            $sql .= ' ORDER BY ' . $sortBy . ' ' . $sortOrder;

            if ($limitCount && ! $pagingApplied) {
                $sql .= ' LIMIT ' . $limitCount . ' OFFSET ' . $limitOffset;
            }

            /** @var (string|int|null)[][][] $tables */
            $tables = $this->fetchResultMultidimensional(
                $sql,
                ['TABLE_SCHEMA', 'TABLE_NAME'],
                null,
                $connectionType,
            );

            // here, we check for Mroonga engine and compute the good data_length and index_length
            // in the StructureController only we need to sum the two values as the other engines
            foreach ($tables as $oneDatabaseName => $oneDatabaseTables) {
                foreach ($oneDatabaseTables as $oneTableName => $oneTableData) {
                    if ($oneTableData['Engine'] !== 'Mroonga') {
                        continue;
                    }

                    if (! StorageEngine::hasMroongaEngine()) {
                        continue;
                    }

                    [
                        $tables[$oneDatabaseName][$oneTableName]['Data_length'],
                        $tables[$oneDatabaseName][$oneTableName]['Index_length'],
                    ] = StorageEngine::getMroongaLengths((string) $oneDatabaseName, (string) $oneTableName);
                }
            }

            if ($sortBy === 'Name' && $this->config->settings['NaturalOrder']) {
                // here, the array's first key is by schema name
                foreach ($tables as $oneDatabaseName => $oneDatabaseTables) {
                    uksort($oneDatabaseTables, strnatcasecmp(...));

                    if ($sortOrder === 'DESC') {
                        $oneDatabaseTables = array_reverse($oneDatabaseTables);
                    }

                    $tables[$oneDatabaseName] = $oneDatabaseTables;
                }
            } elseif ($sortBy === 'Data_length') {
                // Size = Data_length + Index_length
                foreach ($tables as $oneDatabaseName => $oneDatabaseTables) {
                    uasort(
                        $oneDatabaseTables,
                        static function (array $a, array $b): int {
                            $aLength = $a['Data_length'] + $a['Index_length'];
                            $bLength = $b['Data_length'] + $b['Index_length'];

                            return $aLength <=> $bLength;
                        },
                    );

                    if ($sortOrder === 'DESC') {
                        $oneDatabaseTables = array_reverse($oneDatabaseTables);
                    }

                    $tables[$oneDatabaseName] = $oneDatabaseTables;
                }
            }

            // on windows with lower_case_table_names = 1
            // MySQL returns
            // with SHOW DATABASES or information_schema.SCHEMATA: `Test`
            // but information_schema.TABLES gives `test`
            // see https://github.com/phpmyadmin/phpmyadmin/issues/8402
            $tables = $tables[$database]
                ?? $tables[mb_strtolower($database)]
                ?? [];
        }

        // If permissions are wrong on even one database directory,
        // information_schema does not return any table info for any database
        // this is why we fall back to SHOW TABLE STATUS even for MySQL >= 50002
        if ($tables === []) {
            $sql = 'SHOW TABLE STATUS FROM ' . Util::backquote($database);
            if (($table !== '' && $table !== []) || $tableIsGroup || ($tableType !== null && $tableType !== '')) {
                $sql .= ' WHERE';
                $needAnd = false;
                if (($table !== '' && $table !== []) || $tableIsGroup) {
                    if (is_array($table)) {
                        $sql .= ' `Name` IN ('
                            . implode(
                                ', ',
                                array_map(
                                    fn (string $string): string => $this->quoteString($string, $connectionType),
                                    $table,
                                ),
                            ) . ')';
                    } else {
                        $sql .= ' `Name` LIKE '
                            . $this->quoteString($this->escapeMysqlWildcards($table) . '%', $connectionType);
                    }

                    $needAnd = true;
                }

                if ($tableType !== null && $tableType !== '') {
                    if ($needAnd) {
                        $sql .= ' AND';
                    }

                    if ($tableType === 'view') {
                        $sql .= " `Comment` = 'VIEW'";
                    } elseif ($tableType === 'table') {
                        $sql .= " `Comment` != 'VIEW'";
                    }
                }
            }

            /** @var (string|int|null)[][] $eachTables */
            $eachTables = $this->fetchResult($sql, 'Name', null, $connectionType);

            // here, we check for Mroonga engine and compute the good data_length and index_length
            // in the StructureController only we need to sum the two values as the other engines
            foreach ($eachTables as $tableName => $tableData) {
                if ($tableData['Engine'] !== 'Mroonga') {
                    continue;
                }

                if (! StorageEngine::hasMroongaEngine()) {
                    continue;
                }

                [
                    $eachTables[$tableName]['Data_length'],
                    $eachTables[$tableName]['Index_length'],
                ] = StorageEngine::getMroongaLengths($database, (string) $tableName);
            }

            // Sort naturally if the config allows it and we're sorting
            // the Name column.
            if ($sortBy === 'Name' && $this->config->settings['NaturalOrder']) {
                uksort($eachTables, strnatcasecmp(...));

                if ($sortOrder === 'DESC') {
                    $eachTables = array_reverse($eachTables);
                }
            } else {
                // Prepare to sort by creating array of the selected sort
                // value to pass to array_multisort

                // Size = Data_length + Index_length
                $sortValues = [];
                if ($sortBy === 'Data_length') {
                    foreach ($eachTables as $tableName => $tableData) {
                        $sortValues[$tableName] = strtolower(
                            (string) ($tableData['Data_length']
                            + $tableData['Index_length']),
                        );
                    }
                } else {
                    foreach ($eachTables as $tableName => $tableData) {
                        $sortValues[$tableName] = strtolower($tableData[$sortBy] ?? '');
                    }
                }

                if ($sortValues !== []) {
                    // See https://stackoverflow.com/a/32461188 for the explanation of below hack
                    $keys = array_keys($eachTables);
                    if ($sortOrder === 'DESC') {
                        array_multisort($sortValues, SORT_DESC, $eachTables, $keys);

SORT_DESC cannot be passed to array_multisort() as the parameter $rest expects a reference.

                    } else {
                        array_multisort($sortValues, SORT_ASC, $eachTables, $keys);

SORT_ASC cannot be passed to array_multisort() as the parameter $rest expects a reference.

                    }

                    $eachTables = array_combine($keys, $eachTables);
                }

                // cleanup the temporary sort array
                unset($sortValues);
            }

            if ($limitCount && ! $pagingApplied) {
                $eachTables = array_slice($eachTables, $limitOffset, $limitCount, true);
            }

            $tables = Compatibility::getISCompatForGetTablesFull($eachTables, $database);
        }

        if ($tables !== []) {
            // cache table data, so Table does not require to issue SHOW TABLE STATUS again
            $this->cache->cacheTableData($database, $tables);
        }

        return $tables;
    }