libraries/StorageEngine.php

   1 <?php
   2 /* vim: set expandtab sw=4 ts=4 sts=4: */
   3 /**
   4  * Library for extracting information about the available storage engines
   5  *
   6  * @package PhpMyAdmin
   7  */
   8 namespace PMA\libraries;
   9
  10 /**
  11  * defines
  12  */
  13 use PMA\libraries\engines\Bdb;
  14 use PMA\libraries\engines\Berkeleydb;
  15 use PMA\libraries\engines\Binlog;
  16 use PMA\libraries\engines\Innobase;
  17 use PMA\libraries\engines\Innodb;
  18 use PMA\libraries\engines\Memory;
  19 use PMA\libraries\engines\Merge;
  20 use PMA\libraries\engines\Mrg_Myisam;
  21 use PMA\libraries\engines\Myisam;
  22 use PMA\libraries\engines\Ndbcluster;
  23 use PMA\libraries\engines\Pbxt;
  24 use PMA\libraries\engines\Performance_Schema;
  25
  26 define('PMA_ENGINE_SUPPORT_NO', 0);
  27 define('PMA_ENGINE_SUPPORT_DISABLED', 1);
  28 define('PMA_ENGINE_SUPPORT_YES', 2);
  29 define('PMA_ENGINE_SUPPORT_DEFAULT', 3);
  30
  31 define('PMA_ENGINE_DETAILS_TYPE_PLAINTEXT', 0);
  32 define('PMA_ENGINE_DETAILS_TYPE_SIZE',      1);
  33 define('PMA_ENGINE_DETAILS_TYPE_NUMERIC',   2); //Has no effect yet...
  34 define('PMA_ENGINE_DETAILS_TYPE_BOOLEAN',   3); // 'ON' or 'OFF'
  35
  36 /**
  37  * Base Storage Engine Class
  38  *
  39  * @package PhpMyAdmin
  40  */
  41 class StorageEngine
  42 {
  43     /**
  44      * @var string engine name
  45      */
  46     var $engine  = 'dummy';
  47
  48     /**
  49      * @var string engine title/description
  50      */
  51     var $title   = 'PMA Dummy Engine Class';
  52
  53     /**
  54      * @var string engine lang description
  55      */
  56     var $comment
  57         = 'If you read this text inside phpMyAdmin, something went wrong...';
  58
  59     /**
  60      * @var integer engine supported by current server
  61      */
  62     var $support = PMA_ENGINE_SUPPORT_NO;
  63
  64     /**
  65      * Constructor
  66      *
  67      * @param string $engine The engine ID
  68      */
  69     public function __construct($engine)
  70     {
  71         $storage_engines = StorageEngine::getStorageEngines();
  72         if (! empty($storage_engines[$engine])) {
  73             $this->engine  = $engine;
  74             $this->title   = $storage_engines[$engine]['Engine'];
  75             $this->comment = (isset($storage_engines[$engine]['Comment'])
  76                 ? $storage_engines[$engine]['Comment']
  77                 : '');
  78             switch ($storage_engines[$engine]['Support']) {
  79             case 'DEFAULT':
  80                 $this->support = PMA_ENGINE_SUPPORT_DEFAULT;
  81                 break;
  82             case 'YES':
  83                 $this->support = PMA_ENGINE_SUPPORT_YES;
  84                 break;
  85             case 'DISABLED':
  86                 $this->support = PMA_ENGINE_SUPPORT_DISABLED;
  87                 break;
  88             case 'NO':
  89             default:
  90                 $this->support = PMA_ENGINE_SUPPORT_NO;
  91             }
  92         }
  93     }
  94
  95     /**
  96      * Returns array of storage engines
  97      *
  98      * @static
  99      * @staticvar array $storage_engines storage engines
 100      * @access public
 101      * @return string[] array of storage engines
 102      */
 103     static public function getStorageEngines()
 104     {
 105         static $storage_engines = null;
 106
 107         if (null == $storage_engines) {
 108             $storage_engines
 109                 = $GLOBALS['dbi']->fetchResult('SHOW STORAGE ENGINES', 'Engine');
 110             if (PMA_MYSQL_INT_VERSION >= 50708) {
 111                 $disabled = Util::cacheGet(
 112                     'disabled_storage_engines',
 113                     function () {
 114                         return $GLOBALS['dbi']->fetchValue(
 115                             'SELECT @@disabled_storage_engines'
 116                         );
 117                     }
 118                 );
 119                 foreach (explode(",", $disabled) as $engine) {
 120                     if (isset($storage_engines[$engine])) {
 121                         $storage_engines[$engine]['Support'] = 'DISABLED';
 122                     }
 123                 }
 124             }
 125         }
 126
 127         return $storage_engines;
 128     }
 129
 130     /**
 131      * Returns HTML code for storage engine select box
 132      *
 133      * @param string  $name                    The name of the select form element
 134      * @param string  $id                      The ID of the form field
 135      * @param string  $selected                The selected engine
 136      * @param boolean $offerUnavailableEngines Should unavailable storage
 137      *                                         engines be offered?
 138      * @param boolean $addEmpty                Whether to provide empty option
 139      *
 140      * @static
 141      * @return string html selectbox
 142      */
 143     static public function getHtmlSelect(
 144         $name = 'engine', $id = null,
 145         $selected = null, $offerUnavailableEngines = false,
 146         $addEmpty = false
 147     ) {
 148         $selected   = mb_strtolower($selected);
 149         $output     = '<select name="' . $name . '"'
 150             . (empty($id) ? '' : ' id="' . $id . '"') . '>' . "\n";
 151
 152         if ($addEmpty) {
 153             $output .= '<option value=""></option>';
 154         }
 155
 156         foreach (StorageEngine::getStorageEngines() as $key => $details) {
 157             // Don't show PERFORMANCE_SCHEMA engine (MySQL 5.5)
 158             if (! $offerUnavailableEngines
 159                 && ($details['Support'] == 'NO'
 160                 || $details['Support'] == 'DISABLED'
 161                 || $details['Engine'] == 'PERFORMANCE_SCHEMA')
 162             ) {
 163                 continue;
 164             }
 165
 166             $output .= '    <option value="' . htmlspecialchars($key) . '"'
 167                 . (empty($details['Comment'])
 168                     ? '' : ' title="' . htmlspecialchars($details['Comment']) . '"')
 169                 . (mb_strtolower($key) == $selected
 170                     || (empty($selected) && $details['Support'] == 'DEFAULT' && ! $addEmpty)
 171                     ? ' selected="selected"' : '')
 172                 . '>' . "\n"
 173                 . '        ' . htmlspecialchars($details['Engine']) . "\n"
 174                 . '    </option>' . "\n";
 175         }
 176         $output .= '</select>' . "\n";
 177         return $output;
 178     }
 179
 180     /**
 181      * Loads the corresponding engine plugin, if available.
 182      *
 183      * @param string $engine The engine ID
 184      *
 185      * @return StorageEngine The engine plugin
 186      * @static
 187      */
 188     static public function getEngine($engine)
 189     {
 190         switch(strtolower($engine)) {
 191         case 'bdb':
 192             return new Bdb($engine);
 193         case 'berkeleydb':
 194             return new Berkeleydb($engine);
 195         case 'binlog':
 196             return new Binlog($engine);
 197         case 'innobase':
 198             return new Innobase($engine);
 199         case 'innodb':
 200             return new Innodb($engine);
 201         case 'memory':
 202             return new Memory($engine);
 203         case 'merge':
 204             return new Merge($engine);
 205         case 'mrg_myisam':
 206             return new Mrg_Myisam($engine);
 207         case 'myisam':
 208             return new Myisam($engine);
 209         case 'ndbcluster':
 210             return new Ndbcluster($engine);
 211         case 'pbxt':
 212             return new Pbxt($engine);
 213         case 'performance_schema':
 214             return new Performance_Schema($engine);
 215         default:
 216             return new StorageEngine($engine);
 217         }
 218     }
 219
 220     /**
 221      * Returns true if given engine name is supported/valid, otherwise false
 222      *
 223      * @param string $engine name of engine
 224      *
 225      * @static
 226      * @return boolean whether $engine is valid or not
 227      */
 228     static public function isValid($engine)
 229     {
 230         if ($engine == "PBMS") {
 231             return true;
 232         }
 233         $storage_engines = StorageEngine::getStorageEngines();
 234         return isset($storage_engines[$engine]);
 235     }
 236
 237     /**
 238      * Returns as HTML table of the engine's server variables
 239      *
 240      * @return string The table that was generated based on the retrieved
 241      *                information
 242      */
 243     public function getHtmlVariables()
 244     {
 245         $ret        = '';
 246
 247         foreach ($this->getVariablesStatus() as $details) {
 248             $ret .= '<tr>' . "\n"
 249                   . '    <td>' . "\n";
 250             if (! empty($details['desc'])) {
 251                 $ret .= '        '
 252                     . Util::showHint($details['desc'])
 253                     . "\n";
 254             }
 255             $ret .= '    </td>' . "\n"
 256                   . '    <th>' . htmlspecialchars($details['title']) . '</th>'
 257                   . "\n"
 258                   . '    <td class="value">';
 259             switch ($details['type']) {
 260             case PMA_ENGINE_DETAILS_TYPE_SIZE:
 261                 $parsed_size = $this->resolveTypeSize($details['value']);
 262                 $ret .= $parsed_size[0] . '&nbsp;' . $parsed_size[1];
 263                 unset($parsed_size);
 264                 break;
 265             case PMA_ENGINE_DETAILS_TYPE_NUMERIC:
 266                 $ret .= Util::formatNumber($details['value']) . ' ';
 267                 break;
 268             default:
 269                 $ret .= htmlspecialchars($details['value']) . '   ';
 270             }
 271             $ret .= '</td>' . "\n"
 272                   . '</tr>' . "\n";
 273         }
 274
 275         if (! $ret) {
 276             $ret = '<p>' . "\n"
 277                 . '    '
 278                 . __(
 279                     'There is no detailed status information available for this '
 280                     . 'storage engine.'
 281                 )
 282                 . "\n"
 283                 . '</p>' . "\n";
 284         } else {
 285             $ret = '<table class="data">' . "\n" . $ret . '</table>' . "\n";
 286         }
 287
 288         return $ret;
 289     }
 290
 291     /**
 292      * Returns the engine specific handling for
 293      * PMA_ENGINE_DETAILS_TYPE_SIZE type variables.
 294      *
 295      * This function should be overridden when
 296      * PMA_ENGINE_DETAILS_TYPE_SIZE type needs to be
 297      * handled differently for a particular engine.
 298      *
 299      * @param integer $value Value to format
 300      *
 301      * @return string the formatted value and its unit
 302      */
 303     public function resolveTypeSize($value)
 304     {
 305         return Util::formatByteDown($value);
 306     }
 307
 308     /**
 309      * Returns array with detailed info about engine specific server variables
 310      *
 311      * @return array array with detailed info about specific engine server variables
 312      */
 313     public function getVariablesStatus()
 314     {
 315         $variables = $this->getVariables();
 316         $like = $this->getVariablesLikePattern();
 317
 318         if ($like) {
 319             $like = " LIKE '" . $like . "' ";
 320         } else {
 321             $like = '';
 322         }
 323
 324         $mysql_vars = array();
 325
 326         $sql_query = 'SHOW GLOBAL VARIABLES ' . $like . ';';
 327         $res = $GLOBALS['dbi']->query($sql_query);
 328         while ($row = $GLOBALS['dbi']->fetchAssoc($res)) {
 329             if (isset($variables[$row['Variable_name']])) {
 330                 $mysql_vars[$row['Variable_name']]
 331                     = $variables[$row['Variable_name']];
 332             } elseif (! $like
 333                 && mb_strpos(mb_strtolower($row['Variable_name']), mb_strtolower($this->engine)) !== 0
 334             ) {
 335                 continue;
 336             }
 337             $mysql_vars[$row['Variable_name']]['value'] = $row['Value'];
 338
 339             if (empty($mysql_vars[$row['Variable_name']]['title'])) {
 340                 $mysql_vars[$row['Variable_name']]['title'] = $row['Variable_name'];
 341             }
 342
 343             if (! isset($mysql_vars[$row['Variable_name']]['type'])) {
 344                 $mysql_vars[$row['Variable_name']]['type']
 345                     = PMA_ENGINE_DETAILS_TYPE_PLAINTEXT;
 346             }
 347         }
 348         $GLOBALS['dbi']->freeResult($res);
 349
 350         return $mysql_vars;
 351     }
 352
 353     /**
 354      * Reveals the engine's title
 355      *
 356      * @return string The title
 357      */
 358     public function getTitle()
 359     {
 360         return $this->title;
 361     }
 362
 363     /**
 364      * Fetches the server's comment about this engine
 365      *
 366      * @return string The comment
 367      */
 368     public function getComment()
 369     {
 370         return $this->comment;
 371     }
 372
 373     /**
 374      * Information message on whether this storage engine is supported
 375      *
 376      * @return string The localized message.
 377      */
 378     public function getSupportInformationMessage()
 379     {
 380         switch ($this->support) {
 381         case PMA_ENGINE_SUPPORT_DEFAULT:
 382             $message = __('%s is the default storage engine on this MySQL server.');
 383             break;
 384         case PMA_ENGINE_SUPPORT_YES:
 385             $message = __('%s is available on this MySQL server.');
 386             break;
 387         case PMA_ENGINE_SUPPORT_DISABLED:
 388             $message = __('%s has been disabled for this MySQL server.');
 389             break;
 390         case PMA_ENGINE_SUPPORT_NO:
 391         default:
 392             $message = __(
 393                 'This MySQL server does not support the %s storage engine.'
 394             );
 395         }
 396         return sprintf($message, htmlspecialchars($this->title));
 397     }
 398
 399     /**
 400      * Generates a list of MySQL variables that provide information about this
 401      * engine. This function should be overridden when extending this class
 402      * for a particular engine.
 403      *
 404      * @return array The list of variables.
 405      */
 406     public function getVariables()
 407     {
 408         return array();
 409     }
 410
 411     /**
 412      * Returns string with filename for the MySQL helppage
 413      * about this storage engine
 414      *
 415      * @return string MySQL help page filename
 416      */
 417     public function getMysqlHelpPage()
 418     {
 419         return $this->engine . '-storage-engine';
 420     }
 421
 422     /**
 423      * Returns the pattern to be used in the query for SQL variables
 424      * related to the storage engine
 425      *
 426      * @return string SQL query LIKE pattern
 427      */
 428     public function getVariablesLikePattern()
 429     {
 430         return '';
 431     }
 432
 433     /**
 434      * Returns a list of available information pages with labels
 435      *
 436      * @return string[] The list
 437      */
 438     public function getInfoPages()
 439     {
 440         return array();
 441     }
 442
 443     /**
 444      * Generates the requested information page
 445      *
 446      * @param string $id page id
 447      *
 448      * @return string html output
 449      */
 450     public function getPage($id)
 451     {
 452         if (! array_key_exists($id, $this->getInfoPages())) {
 453             return '';
 454         }
 455
 456         $id = 'getPage' . $id;
 457
 458         return $this->$id();
 459     }
 460 }
 461