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