libraries/Index.class.php

   1 <?php
   2 /* vim: set expandtab sw=4 ts=4 sts=4: */
   3 /**
   4  * holds the database index class
   5  *
   6  * @package PhpMyAdmin
   7  */
   8 if (! defined('PHPMYADMIN')) {
   9     exit;
  10 }
  11
  12 /**
  13  *
  14  * @package PhpMyAdmin
  15  * @since   phpMyAdmin 3.0.0
  16  */
  17 class PMA_Index
  18 {
  19     /**
  20      * Class-wide storage container for indexes (caching, singleton)
  21      *
  22      * @var array
  23      */
  24     private static $_registry = array();
  25
  26     /**
  27      * @var string The name of the schema
  28      */
  29     private $_schema = '';
  30
  31     /**
  32      * @var string The name of the table
  33      */
  34     private $_table = '';
  35
  36     /**
  37      * @var string The name of the index
  38      */
  39     private $_name = '';
  40
  41     /**
  42      * Columns in index
  43      *
  44      * @var array
  45      */
  46     private $_columns = array();
  47
  48     /**
  49      * The index method used (BTREE, SPATIAL, FULLTEXT, HASH, RTREE).
  50      *
  51      * @var string
  52      */
  53     private $_type = '';
  54
  55     /**
  56      * The index choice (PRIMARY, UNIQUE, INDEX, SPATIAL, FULLTEXT)
  57      *
  58      * @var string
  59      */
  60     private $_choice = '';
  61
  62     /**
  63      * Various remarks.
  64      *
  65      * @var string
  66      */
  67     private $_remarks = '';
  68
  69     /**
  70      * Any comment provided for the index with a COMMENT attribute when the
  71      * index was created.
  72      *
  73      * @var string
  74      */
  75     private $_comment = '';
  76
  77     /**
  78      * @var integer 0 if the index cannot contain duplicates, 1 if it can.
  79      */
  80     private $_non_unique = 0;
  81
  82     /**
  83      * Indicates how the key is packed. NULL if it is not.
  84      *
  85      * @var string
  86      */
  87     private $_packed = null;
  88
  89     /**
  90      * Constructor
  91      *
  92      * @param array $params parameters
  93      */
  94     public function __construct($params = array())
  95     {
  96         $this->set($params);
  97     }
  98
  99     /**
 100      * Creates(if not already created) and returns the corresponding Index object
 101      *
 102      * @param string $schema     database name
 103      * @param string $table      table name
 104      * @param string $index_name index name
 105      *
 106      * @return object corresponding Index object
 107      */
 108     static public function singleton($schema, $table, $index_name = '')
 109     {
 110         PMA_Index::_loadIndexes($table, $schema);
 111         if (! isset(PMA_Index::$_registry[$schema][$table][$index_name])) {
 112             $index = new PMA_Index;
 113             if (strlen($index_name)) {
 114                 $index->setName($index_name);
 115                 PMA_Index::$_registry[$schema][$table][$index->getName()] = $index;
 116             }
 117             return $index;
 118         } else {
 119             return PMA_Index::$_registry[$schema][$table][$index_name];
 120         }
 121     }
 122
 123     /**
 124      * returns an array with all indexes from the given table
 125      *
 126      * @param string $table  table
 127      * @param string $schema schema
 128      *
 129      * @return array  array of indexes
 130      */
 131     static public function getFromTable($table, $schema)
 132     {
 133         PMA_Index::_loadIndexes($table, $schema);
 134
 135         if (isset(PMA_Index::$_registry[$schema][$table])) {
 136             return PMA_Index::$_registry[$schema][$table];
 137         } else {
 138             return array();
 139         }
 140     }
 141
 142     /**
 143      * return primary if set, false otherwise
 144      *
 145      * @param string $table  table
 146      * @param string $schema schema
 147      *
 148      * @return mixed primary index or false if no one exists
 149      */
 150     static public function getPrimary($table, $schema)
 151     {
 152         PMA_Index::_loadIndexes($table, $schema);
 153
 154         if (isset(PMA_Index::$_registry[$schema][$table]['PRIMARY'])) {
 155             return PMA_Index::$_registry[$schema][$table]['PRIMARY'];
 156         } else {
 157             return false;
 158         }
 159     }
 160
 161     /**
 162      * Load index data for table
 163      *
 164      * @param string $table  table
 165      * @param string $schema schema
 166      *
 167      * @return boolean whether loading was successful
 168      */
 169     static private function _loadIndexes($table, $schema)
 170     {
 171         if (isset(PMA_Index::$_registry[$schema][$table])) {
 172             return true;
 173         }
 174
 175         $_raw_indexes = PMA_DBI_get_table_indexes($schema, $table);
 176         foreach ($_raw_indexes as $_each_index) {
 177             $_each_index['Schema'] = $schema;
 178             if (! isset(PMA_Index::$_registry[$schema][$table][$_each_index['Key_name']])) {
 179                 $key = new PMA_Index($_each_index);
 180                 PMA_Index::$_registry[$schema][$table][$_each_index['Key_name']] = $key;
 181             } else {
 182                 $key = PMA_Index::$_registry[$schema][$table][$_each_index['Key_name']];
 183             }
 184
 185             $key->addColumn($_each_index);
 186         }
 187
 188         return true;
 189     }
 190
 191     /**
 192      * Add column to index
 193      *
 194      * @param array $params column params
 195      *
 196      * @return void
 197      */
 198     public function addColumn($params)
 199     {
 200         if (strlen($params['Column_name'])) {
 201             $this->_columns[$params['Column_name']] = new PMA_Index_Column($params);
 202         }
 203     }
 204
 205     /**
 206      * Adds a list of columns to the index
 207      *
 208      * @param array $columns array containing details about the columns
 209      *
 210      * @return void
 211      */
 212     public function addColumns($columns)
 213     {
 214         $_columns = array();
 215
 216         if (isset($columns['names'])) {
 217             // coming from form
 218             // $columns[names][]
 219             // $columns[sub_parts][]
 220             foreach ($columns['names'] as $key => $name) {
 221                 $sub_part = isset($columns['sub_parts'][$key])
 222                     ? $columns['sub_parts'][$key] : '';
 223                 $_columns[] = array(
 224                     'Column_name'   => $name,
 225                     'Sub_part'      => $sub_part,
 226                 );
 227             }
 228         } else {
 229             // coming from SHOW INDEXES
 230             // $columns[][name]
 231             // $columns[][sub_part]
 232             // ...
 233             $_columns = $columns;
 234         }
 235
 236         foreach ($_columns as $column) {
 237             $this->addColumn($column);
 238         }
 239     }
 240
 241     /**
 242      * Returns true if $column indexed in this index
 243      *
 244      * @param string $column the column
 245      *
 246      * @return boolean  true if $column indexed in this index
 247      */
 248     public function hasColumn($column)
 249     {
 250         return isset($this->_columns[$column]);
 251     }
 252
 253     /**
 254      * Sets index details
 255      *
 256      * @param array $params index details
 257      *
 258      * @return void
 259      */
 260     public function set($params)
 261     {
 262         if (isset($params['columns'])) {
 263             $this->addColumns($params['columns']);
 264         }
 265         if (isset($params['Schema'])) {
 266             $this->_schema = $params['Schema'];
 267         }
 268         if (isset($params['Table'])) {
 269             $this->_table = $params['Table'];
 270         }
 271         if (isset($params['Key_name'])) {
 272             $this->_name = $params['Key_name'];
 273         }
 274         if (isset($params['Index_type'])) {
 275             $this->_type = $params['Index_type'];
 276         }
 277         if (isset($params['Comment'])) {
 278             $this->_remarks = $params['Comment'];
 279         }
 280         if (isset($params['Index_comment'])) {
 281             $this->_comment = $params['Index_comment'];
 282         }
 283         if (isset($params['Non_unique'])) {
 284             $this->_non_unique = $params['Non_unique'];
 285         }
 286         if (isset($params['Packed'])) {
 287             $this->_packed = $params['Packed'];
 288         }
 289         if ('PRIMARY' == $this->_name) {
 290             $this->_choice = 'PRIMARY';
 291         } elseif ('FULLTEXT' == $this->_type) {
 292             $this->_choice = 'FULLTEXT';
 293         } elseif ('SPATIAL' == $this->_type) {
 294             $this->_choice = 'SPATIAL';
 295         } elseif ('0' == $this->_non_unique) {
 296             $this->_choice = 'UNIQUE';
 297         } else {
 298             $this->_choice = 'INDEX';
 299         }
 300     }
 301
 302     /**
 303      * Returns the number of columns of the index
 304      *
 305      * @return integer the number of the columns
 306      */
 307     public function getColumnCount()
 308     {
 309         return count($this->_columns);
 310     }
 311
 312     /**
 313      * Returns the index comment
 314      *
 315      * @return string index comment
 316      */
 317     public function getComment()
 318     {
 319         return $this->_comment;
 320     }
 321
 322     /**
 323      * Returns index remarks
 324      *
 325      * @return string index remarks
 326      */
 327     public function getRemarks()
 328     {
 329         return $this->_remarks;
 330     }
 331
 332     /**
 333      * Returns concatenated remarks and comment
 334      *
 335      * @return string concatenated remarks and comment
 336      */
 337     public function getComments()
 338     {
 339         $comments = $this->getRemarks();
 340         if (strlen($comments)) {
 341             $comments .= "\n";
 342         }
 343         $comments .= $this->getComment();
 344
 345         return $comments;
 346     }
 347
 348     /**
 349      * Returns index type ((BTREE, SPATIAL, FULLTEXT, HASH, RTREE)
 350      *
 351      * @return string index type
 352      */
 353     public function getType()
 354     {
 355         return $this->_type;
 356     }
 357
 358     /**
 359      * Returns index choice (PRIMARY, UNIQUE, INDEX, SPATIAL, FULLTEXT)
 360      *
 361      * @return index choice
 362      */
 363     public function getChoice()
 364     {
 365         return $this->_choice;
 366     }
 367
 368     /**
 369      * Return a list of all index choices
 370      *
 371      * @return array index choices
 372      */
 373     static public function getIndexChoices()
 374     {
 375         return array(
 376             'PRIMARY',
 377             'INDEX',
 378             'UNIQUE',
 379             'SPATIAL',
 380             'FULLTEXT',
 381         );
 382     }
 383
 384     /**
 385      * Returns HTML for the index choice selector
 386      *
 387      * @return string HTML for the index choice selector
 388      */
 389     public function generateIndexSelector()
 390     {
 391         $html_options = '';
 392
 393         foreach (PMA_Index::getIndexChoices() as $each_index_choice) {
 394             if ($each_index_choice === 'PRIMARY'
 395                 && $this->_choice !== 'PRIMARY'
 396                 && PMA_Index::getPrimary($this->_table, $this->_schema)
 397             ) {
 398                 // skip PRIMARY if there is already one in the table
 399                 continue;
 400             }
 401             $html_options .= '<option value="' . $each_index_choice . '"'
 402                  . (($this->_choice == $each_index_choice) ? ' selected="selected"' : '')
 403                  . '>'. $each_index_choice . '</option>' . "\n";
 404         }
 405
 406         return $html_options;
 407     }
 408
 409     /**
 410      * Returns how the index is packed
 411      *
 412      * @return string how the index is packed
 413      */
 414     public function getPacked()
 415     {
 416         return $this->_packed;
 417     }
 418
 419     /**
 420      * Returns 'No'/false if the index is not packed,
 421      * how the index is packed if packed
 422      *
 423      * @param boolean $as_text whether to output should be in text
 424      *
 425      * @return mixed how index is paked
 426      */
 427     public function isPacked($as_text = false)
 428     {
 429         if ($as_text) {
 430             $r = array(
 431                 '0' => __('No'),
 432                 '1' => __('Yes'),
 433             );
 434         } else {
 435             $r = array(
 436                 '0' => false,
 437                 '1' => true,
 438             );
 439         }
 440
 441         if (null === $this->_packed) {
 442             return $r[0];
 443         }
 444
 445         return $this->_packed;
 446     }
 447
 448     /**
 449      * Returns integer 0 if the index cannot contain duplicates, 1 if it can
 450      *
 451      * @return integer 0 if the index cannot contain duplicates, 1 if it can
 452      */
 453     public function getNonUnique()
 454     {
 455         return $this->_non_unique;
 456     }
 457
 458     /**
 459      * Returns whether the index is a 'Unique' index
 460      *
 461      * @param boolean $as_text whether to output should be in text
 462      *
 463      * @return mixed whether the index is a 'Unique' index
 464      */
 465     public function isUnique($as_text = false)
 466     {
 467         if ($as_text) {
 468             $r = array(
 469                 '0' => __('Yes'),
 470                 '1' => __('No'),
 471             );
 472         } else {
 473             $r = array(
 474                 '0' => true,
 475                 '1' => false,
 476             );
 477         }
 478
 479         return $r[$this->_non_unique];
 480     }
 481
 482     /**
 483      * Returns the name of the index
 484      *
 485      * @return string the name of the index
 486      */
 487     public function getName()
 488     {
 489         return $this->_name;
 490     }
 491
 492     /**
 493      * Sets the name of the index
 494      *
 495      * @param string $name index name
 496      *
 497      * @return void
 498      */
 499     public function setName($name)
 500     {
 501         $this->_name = (string) $name;
 502     }
 503
 504     /**
 505      * Returns the columns of the index
 506      *
 507      * @return array the columns of the index
 508      */
 509     public function getColumns()
 510     {
 511         return $this->_columns;
 512     }
 513
 514     /**
 515      * Show index data
 516      *
 517      * @param string  $table      The table name
 518      * @param string  $schema     The schema name
 519      * @param boolean $print_mode Whether the output is for the print mode
 520      *
 521      * @return array  Index collection array
 522      *
 523      * @access  public
 524      */
 525     static public function getView($table, $schema, $print_mode = false)
 526     {
 527         $indexes = PMA_Index::getFromTable($table, $schema);
 528
 529         $no_indexes_class = count($indexes) > 0 ? ' hide' : '';
 530         $no_indexes  = "<div class='no_indexes_defined$no_indexes_class'>";
 531         $no_indexes .= PMA_Message::notice(__('No index defined!'))->getDisplay();
 532         $no_indexes .= '</div>';
 533
 534         if (! $print_mode) {
 535             $r  = '<fieldset class="index_info">';
 536             $r .= '<legend id="index_header">' . __('Indexes');
 537             $r .= PMA_Util::showMySQLDocu(
 538                 'optimization', 'optimizing-database-structure'
 539             );
 540
 541             $r .= '</legend>';
 542             $r .= $no_indexes;
 543             if (count($indexes) < 1) {
 544                 $r .= '</fieldset>';
 545                 return $r;
 546             }
 547             $r .= PMA_Index::findDuplicates($table, $schema);
 548         } else {
 549             $r  = '<h3>' . __('Indexes') . '</h3>';
 550             $r .= $no_indexes;
 551             if (count($indexes) < 1) {
 552                 return $r;
 553             }
 554         }
 555         $r .= '<table id="table_index">';
 556         $r .= '<thead>';
 557         $r .= '<tr>';
 558         if (! $print_mode) {
 559             $r .= '<th colspan="2">' . __('Action') . '</th>';
 560         }
 561         $r .= '<th>' . __('Keyname') . '</th>';
 562         $r .= '<th>' . __('Type') . '</th>';
 563         $r .= '<th>' . __('Unique') . '</th>';
 564         $r .= '<th>' . __('Packed') . '</th>';
 565         $r .= '<th>' . __('Column') . '</th>';
 566         $r .= '<th>' . __('Cardinality') . '</th>';
 567         $r .= '<th>' . __('Collation') . '</th>';
 568         $r .= '<th>' . __('Null') . '</th>';
 569         if (PMA_MYSQL_INT_VERSION > 50500) {
 570             $r .= '<th>' . __('Comment') . '</th>';
 571         }
 572         $r .= '</tr>';
 573         $r .= '</thead>';
 574         $r .= '<tbody>';
 575
 576         $odd_row = true;
 577         foreach ($indexes as $index) {
 578             $row_span = ' rowspan="' . $index->getColumnCount() . '" ';
 579
 580             $r .= '<tr class="noclick ' . ($odd_row ? 'odd' : 'even') . '">';
 581
 582             if (! $print_mode) {
 583                 $this_params = $GLOBALS['url_params'];
 584                 $this_params['index'] = $index->getName();
 585                 $r .= '<td class="edit_index';
 586                 $r .= ' ajax';
 587                 $r .= '" ' . $row_span . '>'
 588                    . '    <a class="';
 589                 $r .= 'ajax';
 590                 $r .= '" href="tbl_indexes.php' . PMA_generate_common_url($this_params)
 591                    . '">' . PMA_Util::getIcon('b_edit.png', __('Edit')) . '</a>'
 592                    . '</td>' . "\n";
 593                 $this_params = $GLOBALS['url_params'];
 594                 if ($index->getName() == 'PRIMARY') {
 595                     $this_params['sql_query'] = 'ALTER TABLE '
 596                         . PMA_Util::backquote($table)
 597                         . ' DROP PRIMARY KEY;';
 598                     $this_params['message_to_show']
 599                         = __('The primary key has been dropped');
 600                     $js_msg = PMA_jsFormat(
 601                         'ALTER TABLE ' . $table . ' DROP PRIMARY KEY'
 602                     );
 603                 } else {
 604                     $this_params['sql_query'] = 'ALTER TABLE '
 605                         . PMA_Util::backquote($table) . ' DROP INDEX '
 606                         . PMA_Util::backquote($index->getName()) . ';';
 607                     $this_params['message_to_show'] = sprintf(
 608                         __('Index %s has been dropped'), $index->getName()
 609                     );
 610
 611                     $js_msg = PMA_jsFormat(
 612                         'ALTER TABLE ' . $table . ' DROP INDEX '
 613                         . $index->getName() . ';'
 614                     );
 615
 616                 }
 617
 618                 $r .= '<td ' . $row_span . '>';
 619                 $r .= '<input type="hidden" class="drop_primary_key_index_msg"'
 620                     . ' value="' . $js_msg . '" />';
 621                 $r .= '    <a class="drop_primary_key_index_anchor';
 622                 $r .= ' ajax';
 623                 $r .= '" href="sql.php' . PMA_generate_common_url($this_params)
 624                    . '" >'
 625                    . PMA_Util::getIcon('b_drop.png', __('Drop'))  . '</a>'
 626                    . '</td>' . "\n";
 627             }
 628
 629             if (! $print_mode) {
 630                 $r .= '<th ' . $row_span . '>'
 631                     . htmlspecialchars($index->getName())
 632                     . '</th>';
 633             } else {
 634                 $r .= '<td ' . $row_span . '>'
 635                     . htmlspecialchars($index->getName())
 636                     . '</td>';
 637             }
 638             $r .= '<td ' . $row_span . '>'
 639                 . htmlspecialchars($index->getType())
 640                 . '</td>';
 641             $r .= '<td ' . $row_span . '>' . $index->isUnique(true) . '</td>';
 642             $r .= '<td ' . $row_span . '>' . $index->isPacked(true) . '</td>';
 643
 644             foreach ($index->getColumns() as $column) {
 645                 if ($column->getSeqInIndex() > 1) {
 646                     $r .= '<tr class="noclick ' . ($odd_row ? 'odd' : 'even') . '">';
 647                 }
 648                 $r .= '<td>' . htmlspecialchars($column->getName());
 649                 if ($column->getSubPart()) {
 650                     $r .= ' (' . $column->getSubPart() . ')';
 651                 }
 652                 $r .= '</td>';
 653                 $r .= '<td>'
 654                     . htmlspecialchars($column->getCardinality())
 655                     . '</td>';
 656                 $r .= '<td>'
 657                     . htmlspecialchars($column->getCollation())
 658                     . '</td>';
 659                 $r .= '<td>'
 660                     . htmlspecialchars($column->getNull(true))
 661                     . '</td>';
 662
 663                 if (PMA_MYSQL_INT_VERSION > 50500
 664                     && $column->getSeqInIndex() == 1) {
 665                     $r .= '<td ' . $row_span . '>'
 666                         . htmlspecialchars($index->getComments()) . '</td>';
 667                 }
 668                 $r .= '</tr>';
 669             } // end foreach $index['Sequences']
 670
 671             $odd_row = ! $odd_row;
 672         } // end while
 673         $r .= '</tbody>';
 674         $r .= '</table>';
 675         if (! $print_mode) {
 676             $r .= '</fieldset>';
 677         }
 678
 679         return $r;
 680     }
 681
 682     public function getCompareData()
 683     {
 684         $data = array(
 685             // 'Non_unique'    => $this->_non_unique,
 686             'Packed'        => $this->_packed,
 687             'Index_type'    => $this->_type,
 688         );
 689
 690         foreach ($this->_columns as $column) {
 691             $data['columns'][] = $column->getCompareData();
 692         }
 693
 694         return $data;
 695     }
 696
 697     /**
 698      * Function to check over array of indexes and look for common problems
 699      *
 700      * @param string $table  table name
 701      * @param string $schema schema name
 702      *
 703      * @return string  Output HTML
 704      * @access  public
 705      */
 706     static public function findDuplicates($table, $schema)
 707     {
 708         $indexes = PMA_Index::getFromTable($table, $schema);
 709
 710         $output  = '';
 711
 712         // count($indexes) < 2:
 713         //   there is no need to check if there less than two indexes
 714         if (count($indexes) < 2) {
 715             return $output;
 716         }
 717
 718         // remove last index from stack and ...
 719         while ($while_index = array_pop($indexes)) {
 720             // ... compare with every remaining index in stack
 721             foreach ($indexes as $each_index) {
 722                 if ($each_index->getCompareData() !== $while_index->getCompareData()) {
 723                     continue;
 724                 }
 725
 726                 // did not find any difference
 727                 // so it makes no sense to have this two equal indexes
 728
 729                 $message = PMA_Message::notice(
 730                     __('The indexes %1$s and %2$s seem to be equal and one of them could possibly be removed.')
 731                 );
 732                 $message->addParam($each_index->getName());
 733                 $message->addParam($while_index->getName());
 734                 $output .= $message->getDisplay();
 735
 736                 // there is no need to check any further indexes if we have already
 737                 // found that this one has a duplicate
 738                 continue 2;
 739             }
 740         }
 741         return $output;
 742     }
 743 }
 744
 745 /**
 746  * @package PhpMyAdmin
 747  */
 748 class PMA_Index_Column
 749 {
 750     /**
 751      * @var string The column name
 752      */
 753     private $_name = '';
 754
 755     /**
 756      * @var integer The column sequence number in the index, starting with 1.
 757      */
 758     private $_seq_in_index = 1;
 759
 760     /**
 761      * @var string How the column is sorted in the index. “A” (Ascending) or
 762      * NULL (Not sorted)
 763      */
 764     private $_collation = null;
 765
 766     /**
 767      * The number of indexed characters if the column is only partly indexed,
 768      * NULL if the entire column is indexed.
 769      *
 770      * @var integer
 771      */
 772     private $_sub_part = null;
 773
 774     /**
 775      * Contains YES if the column may contain NULL.
 776      * If not, the column contains NO.
 777      *
 778      * @var string
 779      */
 780     private $_null = '';
 781
 782     /**
 783      * An estimate of the number of unique values in the index. This is updated
 784      * by running ANALYZE TABLE or myisamchk -a. Cardinality is counted based on
 785      * statistics stored as integers, so the value is not necessarily exact even
 786      * for small tables. The higher the cardinality, the greater the chance that
 787      * MySQL uses the index when doing joins.
 788      *
 789      * @var integer
 790      */
 791     private $_cardinality = null;
 792
 793     public function __construct($params = array())
 794     {
 795         $this->set($params);
 796     }
 797
 798     public function set($params)
 799     {
 800         if (isset($params['Column_name'])) {
 801             $this->_name = $params['Column_name'];
 802         }
 803         if (isset($params['Seq_in_index'])) {
 804             $this->_seq_in_index = $params['Seq_in_index'];
 805         }
 806         if (isset($params['Collation'])) {
 807             $this->_collation = $params['Collation'];
 808         }
 809         if (isset($params['Cardinality'])) {
 810             $this->_cardinality = $params['Cardinality'];
 811         }
 812         if (isset($params['Sub_part'])) {
 813             $this->_sub_part = $params['Sub_part'];
 814         }
 815         if (isset($params['Null'])) {
 816             $this->_null = $params['Null'];
 817         }
 818     }
 819
 820     public function getName()
 821     {
 822         return $this->_name;
 823     }
 824
 825     public function getCollation()
 826     {
 827         return $this->_collation;
 828     }
 829
 830     public function getCardinality()
 831     {
 832         return $this->_cardinality;
 833     }
 834
 835     public function getNull($as_text = false)
 836     {
 837         return $as_text
 838             ? (!$this->_null || $this->_null == 'NO' ? __('No') : __('Yes'))
 839             : $this->_null;
 840     }
 841
 842     public function getSeqInIndex()
 843     {
 844         return $this->_seq_in_index;
 845     }
 846
 847     public function getSubPart()
 848     {
 849         return $this->_sub_part;
 850     }
 851
 852     public function getCompareData()
 853     {
 854         return array(
 855             'Column_name'   => $this->_name,
 856             'Seq_in_index'  => $this->_seq_in_index,
 857             'Collation'     => $this->_collation,
 858             'Sub_part'      => $this->_sub_part,
 859             'Null'          => $this->_null,
 860         );
 861     }
 862 }
 863 ?>