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