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