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 PMA_Index 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 (/*overload*/mb_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             $keyName = $_each_index['Key_name'];
 180             if (! isset(PMA_Index::$_registry[$schema][$table][$keyName])) {
 181                 $key = new PMA_Index($_each_index);
 182                 PMA_Index::$_registry[$schema][$table][$keyName] = $key;
 183             } else {
 184                 $key = PMA_Index::$_registry[$schema][$table][$keyName];
 185             }
 186
 187             $key->addColumn($_each_index);
 188         }
 189
 190         return true;
 191     }
 192
 193     /**
 194      * Add column to index
 195      *
 196      * @param array $params column params
 197      *
 198      * @return void
 199      */
 200     public function addColumn($params)
 201     {
 202         if (isset($params['Column_name'])
 203             && /*overload*/mb_strlen($params['Column_name'])
 204         ) {
 205             $this->_columns[$params['Column_name']] = new PMA_Index_Column($params);
 206         }
 207     }
 208
 209     /**
 210      * Adds a list of columns to the index
 211      *
 212      * @param array $columns array containing details about the columns
 213      *
 214      * @return void
 215      */
 216     public function addColumns($columns)
 217     {
 218         $_columns = array();
 219
 220         if (isset($columns['names'])) {
 221             // coming from form
 222             // $columns[names][]
 223             // $columns[sub_parts][]
 224             foreach ($columns['names'] as $key => $name) {
 225                 $sub_part = isset($columns['sub_parts'][$key])
 226                     ? $columns['sub_parts'][$key] : '';
 227                 $_columns[] = array(
 228                     'Column_name'   => $name,
 229                     'Sub_part'      => $sub_part,
 230                 );
 231             }
 232         } else {
 233             // coming from SHOW INDEXES
 234             // $columns[][name]
 235             // $columns[][sub_part]
 236             // ...
 237             $_columns = $columns;
 238         }
 239
 240         foreach ($_columns as $column) {
 241             $this->addColumn($column);
 242         }
 243     }
 244
 245     /**
 246      * Returns true if $column indexed in this index
 247      *
 248      * @param string $column the column
 249      *
 250      * @return boolean  true if $column indexed in this index
 251      */
 252     public function hasColumn($column)
 253     {
 254         return isset($this->_columns[$column]);
 255     }
 256
 257     /**
 258      * Sets index details
 259      *
 260      * @param array $params index details
 261      *
 262      * @return void
 263      */
 264     public function set($params)
 265     {
 266         if (isset($params['columns'])) {
 267             $this->addColumns($params['columns']);
 268         }
 269         if (isset($params['Schema'])) {
 270             $this->_schema = $params['Schema'];
 271         }
 272         if (isset($params['Table'])) {
 273             $this->_table = $params['Table'];
 274         }
 275         if (isset($params['Key_name'])) {
 276             $this->_name = $params['Key_name'];
 277         }
 278         if (isset($params['Index_type'])) {
 279             $this->_type = $params['Index_type'];
 280         }
 281         if (isset($params['Comment'])) {
 282             $this->_remarks = $params['Comment'];
 283         }
 284         if (isset($params['Index_comment'])) {
 285             $this->_comment = $params['Index_comment'];
 286         }
 287         if (isset($params['Non_unique'])) {
 288             $this->_non_unique = $params['Non_unique'];
 289         }
 290         if (isset($params['Packed'])) {
 291             $this->_packed = $params['Packed'];
 292         }
 293         if ('PRIMARY' == $this->_name) {
 294             $this->_choice = 'PRIMARY';
 295         } elseif ('FULLTEXT' == $this->_type) {
 296             $this->_choice = 'FULLTEXT';
 297         } elseif ('SPATIAL' == $this->_type) {
 298             $this->_choice = 'SPATIAL';
 299         } elseif ('0' == $this->_non_unique) {
 300             $this->_choice = 'UNIQUE';
 301         } else {
 302             $this->_choice = 'INDEX';
 303         }
 304     }
 305
 306     /**
 307      * Returns the number of columns of the index
 308      *
 309      * @return integer the number of the columns
 310      */
 311     public function getColumnCount()
 312     {
 313         return count($this->_columns);
 314     }
 315
 316     /**
 317      * Returns the index comment
 318      *
 319      * @return string index comment
 320      */
 321     public function getComment()
 322     {
 323         return $this->_comment;
 324     }
 325
 326     /**
 327      * Returns index remarks
 328      *
 329      * @return string index remarks
 330      */
 331     public function getRemarks()
 332     {
 333         return $this->_remarks;
 334     }
 335
 336     /**
 337      * Returns concatenated remarks and comment
 338      *
 339      * @return string concatenated remarks and comment
 340      */
 341     public function getComments()
 342     {
 343         $comments = $this->getRemarks();
 344         if (/*overload*/mb_strlen($comments)) {
 345             $comments .= "\n";
 346         }
 347         $comments .= $this->getComment();
 348
 349         return $comments;
 350     }
 351
 352     /**
 353      * Returns index type ((BTREE, SPATIAL, FULLTEXT, HASH, RTREE)
 354      *
 355      * @return string index type
 356      */
 357     public function getType()
 358     {
 359         return $this->_type;
 360     }
 361
 362     /**
 363      * Returns index choice (PRIMARY, UNIQUE, INDEX, SPATIAL, FULLTEXT)
 364      *
 365      * @return string index choice
 366      */
 367     public function getChoice()
 368     {
 369         return $this->_choice;
 370     }
 371
 372     /**
 373      * Return a list of all index choices
 374      *
 375      * @return string[] index choices
 376      */
 377     static public function getIndexChoices()
 378     {
 379         return array(
 380             'PRIMARY',
 381             'INDEX',
 382             'UNIQUE',
 383             'SPATIAL',
 384             'FULLTEXT',
 385         );
 386     }
 387
 388     /**
 389      * Returns HTML for the index choice selector
 390      *
 391      * @return string HTML for the index choice selector
 392      */
 393     public function generateIndexSelector()
 394     {
 395         $html_options = '';
 396
 397         foreach (PMA_Index::getIndexChoices() as $each_index_choice) {
 398             if ($each_index_choice === 'PRIMARY'
 399                 && $this->_choice !== 'PRIMARY'
 400                 && PMA_Index::getPrimary($this->_table, $this->_schema)
 401             ) {
 402                 // skip PRIMARY if there is already one in the table
 403                 continue;
 404             }
 405             $html_options .= '<option value="' . $each_index_choice . '"'
 406                  . (($this->_choice == $each_index_choice)
 407                  ? ' selected="selected"'
 408                  : '')
 409                  . '>' . $each_index_choice . '</option>' . "\n";
 410         }
 411
 412         return $html_options;
 413     }
 414
 415     /**
 416      * Returns how the index is packed
 417      *
 418      * @return string how the index is packed
 419      */
 420     public function getPacked()
 421     {
 422         return $this->_packed;
 423     }
 424
 425     /**
 426      * Returns 'No'/false if the index is not packed,
 427      * how the index is packed if packed
 428      *
 429      * @param boolean $as_text whether to output should be in text
 430      *
 431      * @return mixed how index is packed
 432      */
 433     public function isPacked($as_text = false)
 434     {
 435         if ($as_text) {
 436             $r = array(
 437                 '0' => __('No'),
 438                 '1' => __('Yes'),
 439             );
 440         } else {
 441             $r = array(
 442                 '0' => false,
 443                 '1' => true,
 444             );
 445         }
 446
 447         if (null === $this->_packed) {
 448             return $r[0];
 449         }
 450
 451         return $this->_packed;
 452     }
 453
 454     /**
 455      * Returns integer 0 if the index cannot contain duplicates, 1 if it can
 456      *
 457      * @return integer 0 if the index cannot contain duplicates, 1 if it can
 458      */
 459     public function getNonUnique()
 460     {
 461         return $this->_non_unique;
 462     }
 463
 464     /**
 465      * Returns whether the index is a 'Unique' index
 466      *
 467      * @param boolean $as_text whether to output should be in text
 468      *
 469      * @return mixed whether the index is a 'Unique' index
 470      */
 471     public function isUnique($as_text = false)
 472     {
 473         if ($as_text) {
 474             $r = array(
 475                 '0' => __('Yes'),
 476                 '1' => __('No'),
 477             );
 478         } else {
 479             $r = array(
 480                 '0' => true,
 481                 '1' => false,
 482             );
 483         }
 484
 485         return $r[$this->_non_unique];
 486     }
 487
 488     /**
 489      * Returns the name of the index
 490      *
 491      * @return string the name of the index
 492      */
 493     public function getName()
 494     {
 495         return $this->_name;
 496     }
 497
 498     /**
 499      * Sets the name of the index
 500      *
 501      * @param string $name index name
 502      *
 503      * @return void
 504      */
 505     public function setName($name)
 506     {
 507         $this->_name = (string) $name;
 508     }
 509
 510     /**
 511      * Returns the columns of the index
 512      *
 513      * @return PMA_Index_Column[] the columns of the index
 514      */
 515     public function getColumns()
 516     {
 517         return $this->_columns;
 518     }
 519
 520     /**
 521      * Show index data
 522      *
 523      * @param string  $table      The table name
 524      * @param string  $schema     The schema name
 525      * @param boolean $print_mode Whether the output is for the print mode
 526      *
 527      * @return string HTML for showing index
 528      *
 529      * @access  public
 530      */
 531     static public function getView($table, $schema, $print_mode = false)
 532     {
 533         $indexes = PMA_Index::getFromTable($table, $schema);
 534
 535         $no_indexes_class = count($indexes) > 0 ? ' hide' : '';
 536         $no_indexes  = "<div class='no_indexes_defined$no_indexes_class'>";
 537         $no_indexes .= PMA_Message::notice(__('No index defined!'))->getDisplay();
 538         $no_indexes .= '</div>';
 539
 540         if (! $print_mode) {
 541             $r  = '<fieldset class="index_info">';
 542             $r .= '<legend id="index_header">' . __('Indexes');
 543             $r .= PMA_Util::showMySQLDocu('optimizing-database-structure');
 544
 545             $r .= '</legend>';
 546             $r .= $no_indexes;
 547             if (count($indexes) < 1) {
 548                 $r .= '</fieldset>';
 549                 return $r;
 550             }
 551             $r .= PMA_Index::findDuplicates($table, $schema);
 552         } else {
 553             $r  = '<h3>' . __('Indexes') . '</h3>';
 554             $r .= $no_indexes;
 555             if (count($indexes) < 1) {
 556                 return $r;
 557             }
 558         }
 559         $r .= '<table id="table_index">';
 560         $r .= '<thead>';
 561         $r .= '<tr>';
 562         if (! $print_mode) {
 563             $r .= '<th colspan="2">' . __('Action') . '</th>';
 564         }
 565         $r .= '<th>' . __('Keyname') . '</th>';
 566         $r .= '<th>' . __('Type') . '</th>';
 567         $r .= '<th>' . __('Unique') . '</th>';
 568         $r .= '<th>' . __('Packed') . '</th>';
 569         $r .= '<th>' . __('Column') . '</th>';
 570         $r .= '<th>' . __('Cardinality') . '</th>';
 571         $r .= '<th>' . __('Collation') . '</th>';
 572         $r .= '<th>' . __('Null') . '</th>';
 573         $r .= '<th>' . __('Comment') . '</th>';
 574         $r .= '</tr>';
 575         $r .= '</thead>';
 576         $r .= '<tbody>';
 577
 578         $odd_row = true;
 579         foreach ($indexes as $index) {
 580             $row_span = ' rowspan="' . $index->getColumnCount() . '" ';
 581
 582             $r .= '<tr class="noclick ' . ($odd_row ? 'odd' : 'even') . '">';
 583
 584             if (! $print_mode) {
 585                 $this_params = $GLOBALS['url_params'];
 586                 $this_params['index'] = $index->getName();
 587                 $r .= '<td class="edit_index';
 588                 $r .= ' ajax';
 589                 $r .= '" ' . $row_span . '>'
 590                    . '    <a class="';
 591                 $r .= 'ajax';
 592                 $r .= '" href="tbl_indexes.php' . PMA_URL_getCommon($this_params)
 593                    . '">' . PMA_Util::getIcon('b_edit.png', __('Edit')) . '</a>'
 594                    . '</td>' . "\n";
 595                 $this_params = $GLOBALS['url_params'];
 596                 if ($index->getName() == 'PRIMARY') {
 597                     $this_params['sql_query'] = 'ALTER TABLE '
 598                         . PMA_Util::backquote($table)
 599                         . ' DROP PRIMARY KEY;';
 600                     $this_params['message_to_show']
 601                         = __('The primary key has been dropped.');
 602                     $js_msg = PMA_jsFormat(
 603                         'ALTER TABLE ' . $table . ' DROP PRIMARY KEY'
 604                     );
 605                 } else {
 606                     $this_params['sql_query'] = 'ALTER TABLE '
 607                         . PMA_Util::backquote($table) . ' DROP INDEX '
 608                         . PMA_Util::backquote($index->getName()) . ';';
 609                     $this_params['message_to_show'] = sprintf(
 610                         __('Index %s has been dropped.'), $index->getName()
 611                     );
 612
 613                     $js_msg = PMA_jsFormat(
 614                         'ALTER TABLE ' . $table . ' DROP INDEX '
 615                         . $index->getName() . ';'
 616                     );
 617
 618                 }
 619
 620                 $r .= '<td ' . $row_span . '>';
 621                 $r .= '<input type="hidden" class="drop_primary_key_index_msg"'
 622                     . ' value="' . $js_msg . '" />';
 623                 $r .= '    <a class="drop_primary_key_index_anchor';
 624                 $r .= ' ajax';
 625                 $r .= '" href="sql.php' . PMA_URL_getCommon($this_params)
 626                    . '" >'
 627                    . PMA_Util::getIcon('b_drop.png', __('Drop'))  . '</a>'
 628                    . '</td>' . "\n";
 629             }
 630
 631             if (! $print_mode) {
 632                 $r .= '<th ' . $row_span . '>'
 633                     . htmlspecialchars($index->getName())
 634                     . '</th>';
 635             } else {
 636                 $r .= '<td ' . $row_span . '>'
 637                     . htmlspecialchars($index->getName())
 638                     . '</td>';
 639             }
 640             $r .= '<td ' . $row_span . '>'
 641                 . htmlspecialchars($index->getType())
 642                 . '</td>';
 643             $r .= '<td ' . $row_span . '>' . $index->isUnique(true) . '</td>';
 644             $r .= '<td ' . $row_span . '>' . $index->isPacked(true) . '</td>';
 645
 646             foreach ($index->getColumns() as $column) {
 647                 if ($column->getSeqInIndex() > 1) {
 648                     $r .= '<tr class="noclick ' . ($odd_row ? 'odd' : 'even') . '">';
 649                 }
 650                 $r .= '<td>' . htmlspecialchars($column->getName());
 651                 if ($column->getSubPart()) {
 652                     $r .= ' (' . $column->getSubPart() . ')';
 653                 }
 654                 $r .= '</td>';
 655                 $r .= '<td>'
 656                     . htmlspecialchars($column->getCardinality())
 657                     . '</td>';
 658                 $r .= '<td>'
 659                     . htmlspecialchars($column->getCollation())
 660                     . '</td>';
 661                 $r .= '<td>'
 662                     . htmlspecialchars($column->getNull(true))
 663                     . '</td>';
 664
 665                 if ($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                 ) {
 731                     continue;
 732                 }
 733
 734                 // did not find any difference
 735                 // so it makes no sense to have this two equal indexes
 736
 737                 $message = PMA_Message::notice(
 738                     __('The indexes %1$s and %2$s seem to be equal and one of them could possibly be removed.')
 739                 );
 740                 $message->addParam($each_index->getName());
 741                 $message->addParam($while_index->getName());
 742                 $output .= $message->getDisplay();
 743
 744                 // there is no need to check any further indexes if we have already
 745                 // found that this one has a duplicate
 746                 continue 2;
 747             }
 748         }
 749         return $output;
 750     }
 751 }
 752
 753 /**
 754  * Index column wrapper
 755  *
 756  * @package PhpMyAdmin
 757  */
 758 class PMA_Index_Column
 759 {
 760     /**
 761      * @var string The column name
 762      */
 763     private $_name = '';
 764
 765     /**
 766      * @var integer The column sequence number in the index, starting with 1.
 767      */
 768     private $_seq_in_index = 1;
 769
 770     /**
 771      * @var string How the column is sorted in the index. “A” (Ascending) or
 772      * NULL (Not sorted)
 773      */
 774     private $_collation = null;
 775
 776     /**
 777      * The number of indexed characters if the column is only partly indexed,
 778      * NULL if the entire column is indexed.
 779      *
 780      * @var integer
 781      */
 782     private $_sub_part = null;
 783
 784     /**
 785      * Contains YES if the column may contain NULL.
 786      * If not, the column contains NO.
 787      *
 788      * @var string
 789      */
 790     private $_null = '';
 791
 792     /**
 793      * An estimate of the number of unique values in the index. This is updated
 794      * by running ANALYZE TABLE or myisamchk -a. Cardinality is counted based on
 795      * statistics stored as integers, so the value is not necessarily exact even
 796      * for small tables. The higher the cardinality, the greater the chance that
 797      * MySQL uses the index when doing joins.
 798      *
 799      * @var integer
 800      */
 801     private $_cardinality = null;
 802
 803     /**
 804      * Constructor
 805      *
 806      * @param array $params an array containing the parameters of the index column
 807      */
 808     public function __construct($params = array())
 809     {
 810         $this->set($params);
 811     }
 812
 813     /**
 814      * Sets parameters of the index column
 815      *
 816      * @param array $params an array containing the parameters of the index column
 817      *
 818      * @return void
 819      */
 820     public function set($params)
 821     {
 822         if (isset($params['Column_name'])) {
 823             $this->_name = $params['Column_name'];
 824         }
 825         if (isset($params['Seq_in_index'])) {
 826             $this->_seq_in_index = $params['Seq_in_index'];
 827         }
 828         if (isset($params['Collation'])) {
 829             $this->_collation = $params['Collation'];
 830         }
 831         if (isset($params['Cardinality'])) {
 832             $this->_cardinality = $params['Cardinality'];
 833         }
 834         if (isset($params['Sub_part'])) {
 835             $this->_sub_part = $params['Sub_part'];
 836         }
 837         if (isset($params['Null'])) {
 838             $this->_null = $params['Null'];
 839         }
 840     }
 841
 842     /**
 843      * Returns the column name
 844      *
 845      * @return string column name
 846      */
 847     public function getName()
 848     {
 849         return $this->_name;
 850     }
 851
 852     /**
 853      * Return the column collation
 854      *
 855      * @return string column collation
 856      */
 857     public function getCollation()
 858     {
 859         return $this->_collation;
 860     }
 861
 862     /**
 863      * Returns the cardinality of the column
 864      *
 865      * @return int cardinality of the column
 866      */
 867     public function getCardinality()
 868     {
 869         return $this->_cardinality;
 870     }
 871
 872     /**
 873      * Returns whether the column is nullable
 874      *
 875      * @param boolean $as_text whether to returned the string representation
 876      *
 877      * @return mixed nullability of the column. True/false or Yes/No depending
 878      *               on the value of the $as_text parameter
 879      */
 880     public function getNull($as_text = false)
 881     {
 882         return $as_text
 883             ? (!$this->_null || $this->_null == 'NO' ? __('No') : __('Yes'))
 884             : $this->_null;
 885     }
 886
 887     /**
 888      * Returns the sequence number of the column in the index
 889      *
 890      * @return int sequence number of the column in the index
 891      */
 892     public function getSeqInIndex()
 893     {
 894         return $this->_seq_in_index;
 895     }
 896
 897     /**
 898      * Returns the number of indexed characters if the column is only
 899      * partly indexed
 900      *
 901      * @return int the number of indexed characters
 902      */
 903     public function getSubPart()
 904     {
 905         return $this->_sub_part;
 906     }
 907
 908     /**
 909      * Gets the properties in an array for comparison purposes
 910      *
 911      * @return array an array containing the properties of the index column
 912      */
 913     public function getCompareData()
 914     {
 915         return array(
 916             'Column_name'   => $this->_name,
 917             'Seq_in_index'  => $this->_seq_in_index,
 918             'Collation'     => $this->_collation,
 919             'Sub_part'      => $this->_sub_part,
 920             'Null'          => $this->_null,
 921         );
 922     }
 923 }
 924 ?>