Gecko [ www.vortexaion.com ]

Name	Size	Permission	Date
Charsets	[ DIR ]	drwxrwxrwx	2024-07-26 17:41
Command	[ DIR ]	drwxrwxrwx	2024-07-26 17:41
Config	[ DIR ]	drwxrwxrwx	2024-07-26 17:41
ConfigStorage	[ DIR ]	drwxrwxrwx	2024-07-26 17:41
Controllers	[ DIR ]	drwxrwxrwx	2024-07-26 17:41
Crypto	[ DIR ]	drwxrwxrwx	2024-07-26 17:41
Database	[ DIR ]	drwxrwxrwx	2024-07-26 17:41
Dbal	[ DIR ]	drwxrwxrwx	2024-07-26 17:41
Display	[ DIR ]	drwxrwxrwx	2024-07-26 17:41
Engines	[ DIR ]	drwxrwxrwx	2024-07-26 17:41
Exceptions	[ DIR ]	drwxrwxrwx	2024-07-26 17:41
Export	[ DIR ]	drwxrwxrwx	2024-07-26 17:41
Gis	[ DIR ]	drwxrwxrwx	2024-07-26 17:41
Html	[ DIR ]	drwxrwxrwx	2024-07-26 17:41
Http	[ DIR ]	drwxrwxrwx	2024-07-26 17:41
Image	[ DIR ]	drwxrwxrwx	2024-07-26 17:41
Import	[ DIR ]	drwxrwxrwx	2024-07-26 17:41
Navigation	[ DIR ]	drwxrwxrwx	2024-07-26 17:41
Partitioning	[ DIR ]	drwxrwxrwx	2024-07-26 17:41
Plugins	[ DIR ]	drwxrwxrwx	2024-07-26 17:41
Properties	[ DIR ]	drwxrwxrwx	2024-07-26 17:41
Providers	[ DIR ]	drwxrwxrwx	2024-07-26 17:40
Query	[ DIR ]	drwxrwxrwx	2024-07-26 17:41
Server	[ DIR ]	drwxrwxrwx	2024-07-26 17:41
Setup	[ DIR ]	drwxrwxrwx	2024-07-26 17:41
Table	[ DIR ]	drwxrwxrwx	2024-07-26 17:41
Twig	[ DIR ]	drwxrwxrwx	2024-07-26 17:41
Utils	[ DIR ]	drwxrwxrwx	2024-07-26 17:41
WebAuthn	[ DIR ]	drwxrwxrwx	2024-07-26 17:41
Advisor.php	12.32 KB	-rw-rw-rw-	2023-02-07 22:26
Bookmark.php	9.19 KB	-rw-rw-rw-	2023-02-07 22:26
BrowseForeigners.php	10.63 KB	-rw-rw-rw-	2023-02-07 22:26
Cache.php	1.5 KB	-rw-rw-rw-	2023-02-07 22:26
Charsets.php	6.82 KB	-rw-rw-rw-	2023-02-07 22:26
CheckUserPrivileges.php	11.3 KB	-rw-rw-rw-	2023-02-07 22:26
Common.php	19.4 KB	-rw-rw-rw-	2023-02-07 22:26
Config.php	41.65 KB	-rw-rw-rw-	2023-02-07 22:26
Console.php	3.25 KB	-rw-rw-rw-	2023-02-07 22:26
Core.php	28.91 KB	-rw-rw-rw-	2023-02-07 22:26
CreateAddField.php	15.83 KB	-rw-rw-rw-	2023-02-07 22:26
DatabaseInterface.php	71.73 KB	-rw-rw-rw-	2023-02-07 22:26
DbTableExists.php	2.86 KB	-rw-rw-rw-	2023-02-07 22:26
Encoding.php	8.41 KB	-rw-rw-rw-	2023-02-07 22:26
Error.php	13.63 KB	-rw-rw-rw-	2023-02-07 22:26
ErrorHandler.php	18.63 KB	-rw-rw-rw-	2023-02-07 22:26
ErrorReport.php	8.99 KB	-rw-rw-rw-	2023-02-07 22:26
Export.php	45.7 KB	-rw-rw-rw-	2023-02-07 22:26
FieldMetadata.php	11.11 KB	-rw-rw-rw-	2023-02-07 22:26
File.php	19.75 KB	-rw-rw-rw-	2023-02-07 22:26
FileListing.php	2.88 KB	-rw-rw-rw-	2023-02-07 22:26
FlashMessages.php	1.22 KB	-rw-rw-rw-	2023-02-07 22:26
Font.php	5.58 KB	-rw-rw-rw-	2023-02-07 22:26
Footer.php	8.06 KB	-rw-rw-rw-	2023-02-07 22:26
Git.php	18 KB	-rw-rw-rw-	2023-02-07 22:26
Header.php	20 KB	-rw-rw-rw-	2023-02-07 22:26
Import.php	48.72 KB	-rw-rw-rw-	2023-02-07 22:26
Index.php	14.83 KB	-rw-rw-rw-	2023-02-07 22:26
IndexColumn.php	4.75 KB	-rw-rw-rw-	2023-02-07 22:26
InsertEdit.php	89.05 KB	-rw-rw-rw-	2023-02-07 22:26
InternalRelations.php	17.31 KB	-rw-rw-rw-	2023-02-07 22:26
IpAllowDeny.php	9.13 KB	-rw-rw-rw-	2023-02-07 22:26
Language.php	4.47 KB	-rw-rw-rw-	2023-02-07 22:26
LanguageManager.php	22.74 KB	-rw-rw-rw-	2023-02-07 22:26
Linter.php	4.99 KB	-rw-rw-rw-	2023-02-07 22:26
ListAbstract.php	1.67 KB	-rw-rw-rw-	2023-02-07 22:26
ListDatabase.php	4.11 KB	-rw-rw-rw-	2023-02-07 22:26
Logging.php	2.69 KB	-rw-rw-rw-	2023-02-07 22:26
Menu.php	20.4 KB	-rw-rw-rw-	2023-02-07 22:26
Message.php	18.68 KB	-rw-rw-rw-	2023-02-07 22:26
Mime.php	918 B	-rw-rw-rw-	2023-02-07 22:26
Normalization.php	41.53 KB	-rw-rw-rw-	2023-02-07 22:26
OpenDocument.php	8.62 KB	-rw-rw-rw-	2023-02-07 22:26
Operations.php	35.11 KB	-rw-rw-rw-	2023-02-07 22:26
OutputBuffering.php	4.1 KB	-rw-rw-rw-	2023-02-07 22:26
ParseAnalyze.php	2.34 KB	-rw-rw-rw-	2023-02-07 22:26
Pdf.php	4.17 KB	-rw-rw-rw-	2023-02-07 22:26
Plugins.php	21.83 KB	-rw-rw-rw-	2023-02-07 22:26
Profiling.php	2.16 KB	-rw-rw-rw-	2023-02-07 22:26
RecentFavoriteTable.php	11.44 KB	-rw-rw-rw-	2023-02-07 22:26
Replication.php	4.81 KB	-rw-rw-rw-	2023-02-07 22:26
ReplicationGui.php	21.24 KB	-rw-rw-rw-	2023-02-07 22:26
ReplicationInfo.php	4.79 KB	-rw-rw-rw-	2023-02-07 22:26
ResponseRenderer.php	13.5 KB	-rw-rw-rw-	2023-02-07 22:26
Routing.php	6.55 KB	-rw-rw-rw-	2023-02-07 22:26
Sanitize.php	11.98 KB	-rw-rw-rw-	2023-02-07 22:26
SavedSearches.php	11.33 KB	-rw-rw-rw-	2023-02-07 22:26
Scripts.php	3.74 KB	-rw-rw-rw-	2023-02-07 22:26
Session.php	8.16 KB	-rw-rw-rw-	2023-02-07 22:26
Sql.php	64.01 KB	-rw-rw-rw-	2023-02-07 22:26
SqlQueryForm.php	6.74 KB	-rw-rw-rw-	2023-02-07 22:26
StorageEngine.php	15.71 KB	-rw-rw-rw-	2023-02-07 22:26
SystemDatabase.php	3.98 KB	-rw-rw-rw-	2023-02-07 22:26
Table.php	90.33 KB	-rw-rw-rw-	2023-02-07 22:26
Template.php	4.5 KB	-rw-rw-rw-	2023-02-07 22:26
Theme.php	7.32 KB	-rw-rw-rw-	2023-02-07 22:26
ThemeManager.php	7 KB	-rw-rw-rw-	2023-02-07 22:26
Tracker.php	30.34 KB	-rw-rw-rw-	2023-02-07 22:26
Tracking.php	36.11 KB	-rw-rw-rw-	2023-02-07 22:26
Transformations.php	16.31 KB	-rw-rw-rw-	2023-02-07 22:26
TwoFactor.php	7.49 KB	-rw-rw-rw-	2023-02-07 22:26
Types.php	25.85 KB	-rw-rw-rw-	2023-02-07 22:26
Url.php	10.61 KB	-rw-rw-rw-	2023-02-07 22:26
UrlRedirector.php	1.74 KB	-rw-rw-rw-	2023-02-07 22:26
UserPassword.php	6.86 KB	-rw-rw-rw-	2023-02-07 22:26
UserPreferences.php	10.49 KB	-rw-rw-rw-	2023-02-07 22:26
Util.php	86.45 KB	-rw-rw-rw-	2023-02-07 22:26
Version.php	556 B	-rw-rw-rw-	2023-02-07 22:26
VersionInformation.php	7.3 KB	-rw-rw-rw-	2023-02-07 22:26
ZipExtension.php	10.33 KB	-rw-rw-rw-	2023-02-07 22:26

Rename

<?php

declare(strict_types=1);

namespace PhpMyAdmin;

use function __;
use function array_pop;
use function count;
use function htmlspecialchars;
use function strlen;

/**
 * Index manipulation class
 */
class Index
{
    public const PRIMARY = 1;
    public const UNIQUE = 2;
    public const INDEX = 4;
    public const SPATIAL = 8;
    public const FULLTEXT = 16;

/**
     * Class-wide storage container for indexes (caching, singleton)
     *
     * @var array
     */
    private static $registry = [];

/** @var string The name of the schema */
    private $schema = '';

/** @var string The name of the table */
    private $table = '';

/** @var string The name of the index */
    private $name = '';

/**
     * Columns in index
     *
     * @var array
     */
    private $columns = [];

/**
     * The index method used (BTREE, HASH, RTREE).
     *
     * @var string
     */
    private $type = '';

/**
     * The index choice (PRIMARY, UNIQUE, INDEX, SPATIAL, FULLTEXT)
     *
     * @var string
     */
    private $choice = '';

/**
     * Various remarks.
     *
     * @var string
     */
    private $remarks = '';

/**
     * Any comment provided for the index with a COMMENT attribute when the
     * index was created.
     *
     * @var string
     */
    private $comment = '';

/** @var int 0 if the index cannot contain duplicates, 1 if it can. */
    private $nonUnique = 0;

/**
     * Indicates how the key is packed. NULL if it is not.
     *
     * @var string
     */
    private $packed = null;

/**
     * Block size for the index
     *
     * @var int
     */
    private $keyBlockSize = null;

/**
     * Parser option for the index
     *
     * @var string
     */
    private $parser = null;

/**
     * @param array $params parameters
     */
    public function __construct(array $params = [])
    {
        $this->set($params);
    }

/**
     * Creates(if not already created) and returns the corresponding Index object
     *
     * @param string $schema     database name
     * @param string $table      table name
     * @param string $index_name index name
     *
     * @return Index corresponding Index object
     */
    public static function singleton($schema, $table, $index_name = '')
    {
        self::loadIndexes($table, $schema);
        if (! isset(self::$registry[$schema][$table][$index_name])) {
            $index = new Index();
            if (strlen($index_name) > 0) {
                $index->setName($index_name);
                self::$registry[$schema][$table][$index->getName()] = $index;
            }

return $index;
        }

return self::$registry[$schema][$table][$index_name];
    }

/**
     * returns an array with all indexes from the given table
     *
     * @param string $table  table
     * @param string $schema schema
     *
     * @return Index[]  array of indexes
     */
    public static function getFromTable($table, $schema)
    {
        self::loadIndexes($table, $schema);

if (isset(self::$registry[$schema][$table])) {
            return self::$registry[$schema][$table];
        }

return [];
    }

/**
     * Returns an array with all indexes from the given table of the requested types
     *
     * @param string $table   table
     * @param string $schema  schema
     * @param int    $choices choices
     *
     * @return Index[] array of indexes
     */
    public static function getFromTableByChoice($table, $schema, $choices = 31)
    {
        $indexes = [];
        foreach (self::getFromTable($table, $schema) as $index) {
            if (($choices & self::PRIMARY) && $index->getChoice() === 'PRIMARY') {
                $indexes[] = $index;
            }

if (($choices & self::UNIQUE) && $index->getChoice() === 'UNIQUE') {
                $indexes[] = $index;
            }

if (($choices & self::INDEX) && $index->getChoice() === 'INDEX') {
                $indexes[] = $index;
            }

if (($choices & self::SPATIAL) && $index->getChoice() === 'SPATIAL') {
                $indexes[] = $index;
            }

if ((! ($choices & self::FULLTEXT)) || $index->getChoice() !== 'FULLTEXT') {
                continue;
            }

$indexes[] = $index;
        }

return $indexes;
    }

/**
     * return primary if set, false otherwise
     *
     * @param string $table  table
     * @param string $schema schema
     *
     * @return Index|false primary index or false if no one exists
     */
    public static function getPrimary($table, $schema)
    {
        self::loadIndexes($table, $schema);

if (isset(self::$registry[$schema][$table]['PRIMARY'])) {
            return self::$registry[$schema][$table]['PRIMARY'];
        }

return false;
    }

/**
     * Load index data for table
     *
     * @param string $table  table
     * @param string $schema schema
     */
    private static function loadIndexes($table, $schema): bool
    {
        global $dbi;

if (isset(self::$registry[$schema][$table])) {
            return true;
        }

$_raw_indexes = $dbi->getTableIndexes($schema, $table);
        foreach ($_raw_indexes as $_each_index) {
            $_each_index['Schema'] = $schema;
            $keyName = $_each_index['Key_name'];
            if (! isset(self::$registry[$schema][$table][$keyName])) {
                $key = new Index($_each_index);
                self::$registry[$schema][$table][$keyName] = $key;
            } else {
                $key = self::$registry[$schema][$table][$keyName];
            }

$key->addColumn($_each_index);
        }

return true;
    }

/**
     * Add column to index
     *
     * @param array $params column params
     */
    public function addColumn(array $params): void
    {
        $key = $params['Column_name'] ?? $params['Expression'] ?? '';
        if (isset($params['Expression'])) {
            // The Expression only does not make the key unique, add a sequence number
            $key .= $params['Seq_in_index'];
        }

if (strlen($key) <= 0) {
            return;
        }

$this->columns[$key] = new IndexColumn($params);
    }

/**
     * Adds a list of columns to the index
     *
     * @param array $columns array containing details about the columns
     */
    public function addColumns(array $columns): void
    {
        $_columns = [];

if (isset($columns['names'])) {
            // coming from form
            // $columns[names][]
            // $columns[sub_parts][]
            foreach ($columns['names'] as $key => $name) {
                $sub_part = $columns['sub_parts'][$key] ?? '';
                $_columns[] = [
                    'Column_name' => $name,
                    'Sub_part' => $sub_part,
                ];
            }
        } else {
            // coming from SHOW INDEXES
            // $columns[][name]
            // $columns[][sub_part]
            // ...
            $_columns = $columns;
        }

foreach ($_columns as $column) {
            $this->addColumn($column);
        }
    }

/**
     * Returns true if $column indexed in this index
     *
     * @param string $column the column
     */
    public function hasColumn($column): bool
    {
        return isset($this->columns[$column]);
    }

/**
     * Sets index details
     *
     * @param array $params index details
     */
    public function set(array $params): void
    {
        if (isset($params['columns'])) {
            $this->addColumns($params['columns']);
        }

if (isset($params['Schema'])) {
            $this->schema = $params['Schema'];
        }

if (isset($params['Table'])) {
            $this->table = $params['Table'];
        }

if (isset($params['Key_name'])) {
            $this->name = $params['Key_name'];
        }

if (isset($params['Index_type'])) {
            $this->type = $params['Index_type'];
        }

if (isset($params['Comment'])) {
            $this->remarks = $params['Comment'];
        }

if (isset($params['Index_comment'])) {
            $this->comment = $params['Index_comment'];
        }

if (isset($params['Non_unique'])) {
            $this->nonUnique = $params['Non_unique'];
        }

if (isset($params['Packed'])) {
            $this->packed = $params['Packed'];
        }

if (isset($params['Index_choice'])) {
            $this->choice = $params['Index_choice'];
        } elseif ($this->name === 'PRIMARY') {
            $this->choice = 'PRIMARY';
        } elseif ($this->type === 'FULLTEXT') {
            $this->choice = 'FULLTEXT';
            $this->type = '';
        } elseif ($this->type === 'SPATIAL') {
            $this->choice = 'SPATIAL';
            $this->type = '';
        } elseif ($this->nonUnique == '0') {
            $this->choice = 'UNIQUE';
        } else {
            $this->choice = 'INDEX';
        }

if (isset($params['Key_block_size'])) {
            $this->keyBlockSize = $params['Key_block_size'];
        }

if (! isset($params['Parser'])) {
            return;
        }

$this->parser = $params['Parser'];
    }

/**
     * Returns the number of columns of the index
     *
     * @return int the number of the columns
     */
    public function getColumnCount()
    {
        return count($this->columns);
    }

/**
     * Returns the index comment
     *
     * @return string index comment
     */
    public function getComment()
    {
        return $this->comment;
    }

/**
     * Returns index remarks
     *
     * @return string index remarks
     */
    public function getRemarks()
    {
        return $this->remarks;
    }

/**
     * Return the key block size
     *
     * @return int
     */
    public function getKeyBlockSize()
    {
        return $this->keyBlockSize;
    }

/**
     * Return the parser
     *
     * @return string
     */
    public function getParser()
    {
        return $this->parser;
    }

/**
     * Returns concatenated remarks and comment
     *
     * @return string concatenated remarks and comment
     */
    public function getComments()
    {
        $comments = $this->getRemarks();
        if (strlen($comments) > 0) {
            $comments .= "\n";
        }

$comments .= $this->getComment();

return $comments;
    }

/**
     * Returns index type (BTREE, HASH, RTREE)
     *
     * @return string index type
     */
    public function getType()
    {
        return $this->type;
    }

/**
     * Returns index choice (PRIMARY, UNIQUE, INDEX, SPATIAL, FULLTEXT)
     *
     * @return string index choice
     */
    public function getChoice()
    {
        return $this->choice;
    }

/**
     * Returns a lit of all index types
     *
     * @return string[] index types
     */
    public static function getIndexTypes()
    {
        return [
            'BTREE',
            'HASH',
        ];
    }

public function hasPrimary(): bool
    {
        return (bool) self::getPrimary($this->table, $this->schema);
    }

/**
     * Returns how the index is packed
     *
     * @return string how the index is packed
     */
    public function getPacked()
    {
        return $this->packed;
    }

/**
     * Returns 'No' if the index is not packed,
     * how the index is packed if packed
     *
     * @return string
     */
    public function isPacked()
    {
        if ($this->packed === null) {
            return __('No');
        }

return htmlspecialchars($this->packed);
    }

/**
     * Returns integer 0 if the index cannot contain duplicates, 1 if it can
     *
     * @return int 0 if the index cannot contain duplicates, 1 if it can
     */
    public function getNonUnique()
    {
        return $this->nonUnique;
    }

/**
     * Returns whether the index is a 'Unique' index
     *
     * @param bool $as_text whether to output should be in text
     *
     * @return mixed whether the index is a 'Unique' index
     */
    public function isUnique($as_text = false)
    {
        if ($as_text) {
            $r = [
                '0' => __('Yes'),
                '1' => __('No'),
            ];
        } else {
            $r = [
                '0' => true,
                '1' => false,
            ];
        }

return $r[$this->nonUnique];
    }

/**
     * Returns the name of the index
     *
     * @return string the name of the index
     */
    public function getName()
    {
        return $this->name;
    }

/**
     * Sets the name of the index
     *
     * @param string $name index name
     */
    public function setName($name): void
    {
        $this->name = (string) $name;
    }

/**
     * Returns the columns of the index
     *
     * @return IndexColumn[] the columns of the index
     */
    public function getColumns()
    {
        return $this->columns;
    }

/**
     * Gets the properties in an array for comparison purposes
     *
     * @return array an array containing the properties of the index
     */
    public function getCompareData()
    {
        $data = [
            'Packed' => $this->packed,
            'Index_choice' => $this->choice,
        ];

foreach ($this->columns as $column) {
            $data['columns'][] = $column->getCompareData();
        }

return $data;
    }

/**
     * Function to check over array of indexes and look for common problems
     *
     * @param string $table  table name
     * @param string $schema schema name
     *
     * @return string  Output HTML
     */
    public static function findDuplicates($table, $schema)
    {
        $indexes = self::getFromTable($table, $schema);

$output = '';

// count($indexes) < 2:
        //   there is no need to check if there less than two indexes
        if (count($indexes) < 2) {
            return $output;
        }

// remove last index from stack and ...
        while ($while_index = array_pop($indexes)) {
            // ... compare with every remaining index in stack
            foreach ($indexes as $each_index) {
                if ($each_index->getCompareData() !== $while_index->getCompareData()) {
                    continue;
                }

// did not find any difference
                // so it makes no sense to have this two equal indexes

$message = Message::notice(
                    __(
                        'The indexes %1$s and %2$s seem to be equal and one of them could possibly be removed.'
                    )
                );
                $message->addParam($each_index->getName());
                $message->addParam($while_index->getName());
                $output .= $message->getDisplay();

// there is no need to check any further indexes if we have already
                // found that this one has a duplicate
                continue 2;
            }
        }

return $output;
    }
}