src/Index.php

   1 <?php
   2
   3 declare(strict_types=1);
   4
   5 namespace PhpMyAdmin;
   6
   7 use function __;
   8 use function array_pop;
   9 use function count;
  10 use function htmlspecialchars;
  11
  12 /**
  13  * Index manipulation class
  14  */
  15 class Index
  16 {
  17     public const PRIMARY = 1;
  18     public const UNIQUE = 2;
  19     public const INDEX = 4;
  20     public const SPATIAL = 8;
  21     public const FULLTEXT = 16;
  22
  23     /**
  24      * Class-wide storage container for indexes (caching, singleton)
  25      *
  26      * @var array<string, array<string, array<string, Index>>>
  27      */
  28     private static array $registry = [];
  29
  30     /** @var string The name of the schema */
  31     private string $schema = '';
  32
  33     /** @var string The name of the table */
  34     private string $table = '';
  35
  36     /** @var string The name of the index */
  37     private string $name = '';
  38
  39     /**
  40      * Columns in index
  41      *
  42      * @var array<string|int, IndexColumn>
  43      */
  44     private array $columns = [];
  45
  46     /**
  47      * The index method used (BTREE, HASH, RTREE).
  48      */
  49     private string $type = '';
  50
  51     /**
  52      * The index choice (PRIMARY, UNIQUE, INDEX, SPATIAL, FULLTEXT)
  53      */
  54     private string $choice = '';
  55
  56     /**
  57      * Various remarks.
  58      */
  59     private string $remarks = '';
  60
  61     /**
  62      * Any comment provided for the index with a COMMENT attribute when the
  63      * index was created.
  64      */
  65     private string $comment = '';
  66
  67     /** @var bool false if the index cannot contain duplicates, true if it can. */
  68     private bool $nonUnique = false;
  69
  70     /**
  71      * Indicates how the key is packed. NULL if it is not.
  72      */
  73     private string|null $packed = null;
  74
  75     /**
  76      * Block size for the index
  77      */
  78     private int $keyBlockSize = 0;
  79
  80     /**
  81      * Parser option for the index
  82      */
  83     private string $parser = '';
  84
  85     /** @param mixed[] $params parameters */
  86     public function __construct(array $params = [])
  87     {
  88         $this->set($params);
  89     }
  90
  91     /**
  92      * Creates (if not already created) and returns the corresponding Index object
  93      *
  94      * @return Index corresponding Index object
  95      */
  96     public static function singleton(
  97         DatabaseInterface $dbi,
  98         string $schema,
  99         string $table,
 100         string $indexName = '',
 101     ): Index {
 102         self::loadIndexes($dbi, $table, $schema);
 103         if (isset(self::$registry[$schema][$table][$indexName])) {
 104             return self::$registry[$schema][$table][$indexName];
 105         }
 106
 107         $index = new Index();
 108         if ($indexName !== '') {
 109             $index->setName($indexName);
 110             self::$registry[$schema][$table][$index->getName()] = $index;
 111         }
 112
 113         return $index;
 114     }
 115
 116     /**
 117      * returns an array with all indexes from the given table
 118      *
 119      * @return Index[]
 120      */
 121     public static function getFromTable(DatabaseInterface $dbi, string $table, string $schema): array
 122     {
 123         self::loadIndexes($dbi, $table, $schema);
 124
 125         return self::$registry[$schema][$table] ?? [];
 126     }
 127
 128     /**
 129      * Returns an array with all indexes from the given table of the requested types
 130      *
 131      * @param string $table   table
 132      * @param string $schema  schema
 133      * @param int    $choices choices
 134      *
 135      * @return Index[] array of indexes
 136      */
 137     public static function getFromTableByChoice(string $table, string $schema, int $choices = 31): array
 138     {
 139         $indexes = [];
 140         foreach (self::getFromTable(DatabaseInterface::getInstance(), $table, $schema) as $index) {
 141             if (($choices & self::PRIMARY) && $index->getChoice() === 'PRIMARY') {
 142                 $indexes[] = $index;
 143             }
 144
 145             if (($choices & self::UNIQUE) && $index->getChoice() === 'UNIQUE') {
 146                 $indexes[] = $index;
 147             }
 148
 149             if (($choices & self::INDEX) && $index->getChoice() === 'INDEX') {
 150                 $indexes[] = $index;
 151             }
 152
 153             if (($choices & self::SPATIAL) && $index->getChoice() === 'SPATIAL') {
 154                 $indexes[] = $index;
 155             }
 156
 157             if ((($choices & self::FULLTEXT) === 0) || $index->getChoice() !== 'FULLTEXT') {
 158                 continue;
 159             }
 160
 161             $indexes[] = $index;
 162         }
 163
 164         return $indexes;
 165     }
 166
 167     public static function getPrimary(DatabaseInterface $dbi, string $table, string $schema): Index|null
 168     {
 169         self::loadIndexes($dbi, $table, $schema);
 170
 171         return self::$registry[$schema][$table]['PRIMARY'] ?? null;
 172     }
 173
 174     /**
 175      * Load index data for table
 176      */
 177     private static function loadIndexes(DatabaseInterface $dbi, string $table, string $schema): void
 178     {
 179         if (isset(self::$registry[$schema][$table])) {
 180             return;
 181         }
 182
 183         $rawIndexes = $dbi->getTableIndexes($schema, $table);
 184         foreach ($rawIndexes as $eachIndex) {
 185             $eachIndex['Schema'] = $schema;
 186             $keyName = $eachIndex['Key_name'];
 187             if (! isset(self::$registry[$schema][$table][$keyName])) {
 188                 $key = new Index($eachIndex);
 189                 self::$registry[$schema][$table][$keyName] = $key;
 190             } else {
 191                 $key = self::$registry[$schema][$table][$keyName];
 192             }
 193
 194             $key->addColumn($eachIndex);
 195         }
 196     }
 197
 198     /**
 199      * Add column to index
 200      *
 201      * @param array<string, string|null> $params column params
 202      */
 203     public function addColumn(array $params): void
 204     {
 205         $key = $params['Column_name'] ?? $params['Expression'] ?? '';
 206         if (isset($params['Expression'])) {
 207             // The Expression only does not make the key unique, add a sequence number
 208             $key .= $params['Seq_in_index'];
 209         }
 210
 211         if ($key === '') {
 212             return;
 213         }
 214
 215         $this->columns[$key] = new IndexColumn($params);
 216     }
 217
 218     /**
 219      * Adds a list of columns to the index
 220      *
 221      * @param mixed[] $columns array containing details about the columns
 222      */
 223     public function addColumns(array $columns): void
 224     {
 225         $addedColumns = [];
 226
 227         if (isset($columns['names'])) {
 228             // coming from form
 229             // $columns[names][]
 230             // $columns[sub_parts][]
 231             foreach ($columns['names'] as $key => $name) {
 232                 $subPart = $columns['sub_parts'][$key] ?? '';
 233                 $addedColumns[] = ['Column_name' => $name, 'Sub_part' => $subPart];
 234             }
 235         } else {
 236             // coming from SHOW INDEXES
 237             // $columns[][name]
 238             // $columns[][sub_part]
 239             // ...
 240             $addedColumns = $columns;
 241         }
 242
 243         foreach ($addedColumns as $column) {
 244             $this->addColumn($column);
 245         }
 246     }
 247
 248     /**
 249      * Returns true if $column indexed in this index
 250      *
 251      * @param string $column the column
 252      */
 253     public function hasColumn(string $column): bool
 254     {
 255         return isset($this->columns[$column]);
 256     }
 257
 258     /**
 259      * Sets index details
 260      *
 261      * @param mixed[] $params index details
 262      */
 263     public function set(array $params): void
 264     {
 265         if (isset($params['columns'])) {
 266             $this->addColumns($params['columns']);
 267         }
 268
 269         if (isset($params['Schema'])) {
 270             $this->schema = $params['Schema'];
 271         }
 272
 273         if (isset($params['Table'])) {
 274             $this->table = $params['Table'];
 275         }
 276
 277         if (isset($params['Key_name'])) {
 278             $this->name = $params['Key_name'];
 279         }
 280
 281         if (isset($params['Index_type'])) {
 282             $this->type = $params['Index_type'];
 283         }
 284
 285         if (isset($params['Comment'])) {
 286             $this->remarks = $params['Comment'];
 287         }
 288
 289         if (isset($params['Index_comment'])) {
 290             $this->comment = $params['Index_comment'];
 291         }
 292
 293         if (isset($params['Non_unique'])) {
 294             $this->nonUnique = (bool) $params['Non_unique'];
 295         }
 296
 297         if (isset($params['Packed'])) {
 298             $this->packed = $params['Packed'];
 299         }
 300
 301         if (isset($params['Index_choice'])) {
 302             $this->choice = $params['Index_choice'];
 303         } elseif ($this->name === 'PRIMARY') {
 304             $this->choice = 'PRIMARY';
 305         } elseif ($this->type === 'FULLTEXT') {
 306             $this->choice = 'FULLTEXT';
 307             $this->type = '';
 308         } elseif ($this->type === 'SPATIAL') {
 309             $this->choice = 'SPATIAL';
 310             $this->type = '';
 311         } elseif (! $this->nonUnique) {
 312             $this->choice = 'UNIQUE';
 313         } else {
 314             $this->choice = 'INDEX';
 315         }
 316
 317         if (isset($params['Key_block_size'])) {
 318             $this->keyBlockSize = (int) $params['Key_block_size'];
 319         }
 320
 321         if (! isset($params['Parser'])) {
 322             return;
 323         }
 324
 325         $this->parser = $params['Parser'];
 326     }
 327
 328     /**
 329      * Returns the number of columns of the index
 330      *
 331      * @return int the number of the columns
 332      */
 333     public function getColumnCount(): int
 334     {
 335         return count($this->columns);
 336     }
 337
 338     /**
 339      * Returns the index comment
 340      *
 341      * @return string index comment
 342      */
 343     public function getComment(): string
 344     {
 345         return $this->comment;
 346     }
 347
 348     /**
 349      * Returns index remarks
 350      *
 351      * @return string index remarks
 352      */
 353     public function getRemarks(): string
 354     {
 355         return $this->remarks;
 356     }
 357
 358     /**
 359      * Return the key block size
 360      */
 361     public function getKeyBlockSize(): int
 362     {
 363         return $this->keyBlockSize;
 364     }
 365
 366     /**
 367      * Return the parser
 368      */
 369     public function getParser(): string
 370     {
 371         return $this->parser;
 372     }
 373
 374     /**
 375      * Returns concatenated remarks and comment
 376      *
 377      * @return string concatenated remarks and comment
 378      */
 379     public function getComments(): string
 380     {
 381         $comments = $this->getRemarks();
 382         if ($comments !== '') {
 383             $comments .= "\n";
 384         }
 385
 386         $comments .= $this->getComment();
 387
 388         return $comments;
 389     }
 390
 391     /**
 392      * Returns index type (BTREE, HASH, RTREE)
 393      *
 394      * @return string index type
 395      */
 396     public function getType(): string
 397     {
 398         return $this->type;
 399     }
 400
 401     /**
 402      * Returns index choice (PRIMARY, UNIQUE, INDEX, SPATIAL, FULLTEXT)
 403      *
 404      * @return string index choice
 405      */
 406     public function getChoice(): string
 407     {
 408         return $this->choice;
 409     }
 410
 411     /**
 412      * Returns a lit of all index types
 413      *
 414      * @return string[] index types
 415      */
 416     public static function getIndexTypes(): array
 417     {
 418         return ['BTREE', 'HASH'];
 419     }
 420
 421     public function hasPrimary(): bool
 422     {
 423         return self::getPrimary(DatabaseInterface::getInstance(), $this->table, $this->schema) !== null;
 424     }
 425
 426     /**
 427      * Returns how the index is packed
 428      *
 429      * @return string|null how the index is packed
 430      */
 431     public function getPacked(): string|null
 432     {
 433         return $this->packed;
 434     }
 435
 436     /**
 437      * Returns 'No' if the index is not packed,
 438      * how the index is packed if packed
 439      */
 440     public function isPacked(): string
 441     {
 442         if ($this->packed === null) {
 443             return __('No');
 444         }
 445
 446         return htmlspecialchars($this->packed);
 447     }
 448
 449     /**
 450      * Returns bool false if the index cannot contain duplicates, true if it can
 451      *
 452      * @return bool false if the index cannot contain duplicates, true if it can
 453      */
 454     public function getNonUnique(): bool
 455     {
 456         return $this->nonUnique;
 457     }
 458
 459     /**
 460      * Returns whether the index is a 'Unique' index
 461      *
 462      * @param bool $asText whether to output should be in text
 463      *
 464      * @return string|bool whether the index is a 'Unique' index
 465      */
 466     public function isUnique(bool $asText = false): string|bool
 467     {
 468         if ($asText) {
 469             return $this->nonUnique ? __('No') : __('Yes');
 470         }
 471
 472         return ! $this->nonUnique;
 473     }
 474
 475     /**
 476      * Returns the name of the index
 477      *
 478      * @return string the name of the index
 479      */
 480     public function getName(): string
 481     {
 482         return $this->name;
 483     }
 484
 485     /**
 486      * Sets the name of the index
 487      */
 488     public function setName(string $name): void
 489     {
 490         $this->name = $name;
 491     }
 492
 493     /**
 494      * Returns the columns of the index
 495      *
 496      * @return IndexColumn[]
 497      */
 498     public function getColumns(): array
 499     {
 500         return $this->columns;
 501     }
 502
 503     /**
 504      * Gets the properties in an array for comparison purposes
 505      *
 506      * @return array<string, array<int, array<string, int|string|null>>|string|null>
 507      * @psalm-return array{
 508      *   Packed: string|null,
 509      *   Index_choice: string,
 510      *   columns?: list<array{
 511      *     Column_name: string,
 512      *     Seq_in_index: int,
 513      *     Collation: string|null,
 514      *     Sub_part: int|null,
 515      *     Null: string
 516      *   }>
 517      * }
 518      */
 519     public function getCompareData(): array
 520     {
 521         $data = ['Packed' => $this->packed, 'Index_choice' => $this->choice];
 522
 523         foreach ($this->columns as $column) {
 524             $data['columns'][] = $column->getCompareData();
 525         }
 526
 527         return $data;
 528     }
 529
 530     /**
 531      * Function to check over array of indexes and look for common problems
 532      *
 533      * @param string $table  table name
 534      * @param string $schema schema name
 535      *
 536      * @return string  Output HTML
 537      */
 538     public static function findDuplicates(string $table, string $schema): string
 539     {
 540         $indexes = self::getFromTable(DatabaseInterface::getInstance(), $table, $schema);
 541
 542         $output = '';
 543
 544         // count($indexes) < 2:
 545         //   there is no need to check if there less than two indexes
 546         if (count($indexes) < 2) {
 547             return $output;
 548         }
 549
 550         // remove last index from stack and ...
 551         while ($whileIndex = array_pop($indexes)) {
 552             // ... compare with every remaining index in stack
 553             foreach ($indexes as $eachIndex) {
 554                 if ($eachIndex->getCompareData() !== $whileIndex->getCompareData()) {
 555                     continue;
 556                 }
 557
 558                 // did not find any difference
 559                 // so it makes no sense to have this two equal indexes
 560
 561                 $message = Message::notice(
 562                     __(
 563                         'The indexes %1$s and %2$s seem to be equal and one of them could possibly be removed.',
 564                     ),
 565                 );
 566                 $message->addParam($eachIndex->getName());
 567                 $message->addParam($whileIndex->getName());
 568                 $output .= $message->getDisplay();
 569
 570                 // there is no need to check any further indexes if we have already
 571                 // found that this one has a duplicate
 572                 continue 2;
 573             }
 574         }
 575
 576         return $output;
 577     }
 578 }