phpmyadmin/libraries/navigation/Nodes/Node.class.php

   1 <?php
   2 /* vim: set expandtab sw=4 ts=4 sts=4: */
   3 /**
   4  * Functionality for the navigation tree in the left frame
   5  *
   6  * @package PhpMyAdmin-Navigation
   7  */
   8 if (! defined('PHPMYADMIN')) {
   9     exit;
  10 }
  11
  12 /**
  13  * The Node is the building block for the collapsible navigation tree
  14  *
  15  * @package PhpMyAdmin-Navigation
  16  */
  17 class Node
  18 {
  19     /**
  20      * @var int Defines a possible node type
  21      */
  22     const CONTAINER = 0;
  23
  24     /**
  25      * @var int Defines a possible node type
  26      */
  27     const OBJECT = 1;
  28
  29     /**
  30      * @var string A non-unique identifier for the node
  31      *             This may be trimmed when grouping nodes
  32      */
  33     public $name = "";
  34
  35     /**
  36      * @var string A non-unique identifier for the node
  37      *             This will never change after being assigned
  38      */
  39     public $real_name = "";
  40
  41     /**
  42      * @var int May be one of CONTAINER or OBJECT
  43      */
  44     public $type = Node::OBJECT;
  45
  46     /**
  47      * @var bool Whether this object has been created while grouping nodes
  48      *           Only relevant if the node is of type CONTAINER
  49      */
  50     public $is_group;
  51
  52     /**
  53      * @var bool Whether to add a "display: none;" CSS
  54      *           rule to the node when rendering it
  55      */
  56     public $visible = false;
  57
  58     /**
  59      * @var Node A reference to the parent object of
  60      *           this node, NULL for the root node.
  61      */
  62     public $parent;
  63
  64     /**
  65      * @var Node[] An array of Node objects that are
  66      *             direct children of this node
  67      */
  68     public $children = array();
  69
  70     /**
  71      * @var Mixed A string used to group nodes, or an array of strings
  72      *            Only relevant if the node is of type CONTAINER
  73      */
  74     public $separator = '';
  75
  76     /**
  77      * @var int How many time to recursively apply the grouping function
  78      *          Only relevant if the node is of type CONTAINER
  79      */
  80     public $separator_depth = 1;
  81
  82     /**
  83      * @var string An IMG tag, used when rendering the node
  84      */
  85     public $icon;
  86
  87     /**
  88      * @var Array An array of A tags, used when rendering the node
  89      *            The indexes in the array may be 'icon' and 'text'
  90      */
  91     public $links;
  92
  93     /**
  94      * @var string HTML title
  95      */
  96     public $title;
  97
  98     /**
  99      * @var string Extra CSS classes for the node
 100      */
 101     public $classes = '';
 102
 103     /**
 104      * @var bool Whether this node is a link for creating new objects
 105      */
 106     public $isNew = false;
 107
 108     /**
 109      * @var int The position for the pagination of
 110      *          the branch at the second level of the tree
 111      */
 112     public $pos2 = 0;
 113
 114     /**
 115      * @var int The position for the pagination of
 116      *          the branch at the third level of the tree
 117      */
 118     public $pos3 = 0;
 119
 120     /**
 121      * Initialises the class by setting the mandatory variables
 122      *
 123      * @param string $name     An identifier for the new node
 124      * @param int    $type     Type of node, may be one of CONTAINER or OBJECT
 125      * @param bool   $is_group Whether this object has been created
 126      *                         while grouping nodes
 127      */
 128     public function __construct($name, $type = Node::OBJECT, $is_group = false)
 129     {
 130         if (! empty($name)) {
 131             $this->name      = $name;
 132             $this->real_name = $name;
 133         }
 134         if ($type === Node::CONTAINER) {
 135             $this->type = Node::CONTAINER;
 136         }
 137         $this->is_group = (bool)$is_group;
 138     }
 139
 140     /**
 141      * Adds a child node to this node
 142      *
 143      * @param Node $child A child node
 144      *
 145      * @return void
 146      */
 147     public function addChild($child)
 148     {
 149         $this->children[] = $child;
 150         $child->parent    = $this;
 151     }
 152
 153     /**
 154      * Returns a child node given it's name
 155      *
 156      * @param string $name      The name of requested child
 157      * @param bool   $real_name Whether to use the "real_name"
 158      *                          instead of "name" in comparisons
 159      *
 160      * @return false|Node The requested child node or false,
 161      *                    if the requested node cannot be found
 162      */
 163     public function getChild($name, $real_name = false)
 164     {
 165         if ($real_name) {
 166             foreach ($this->children as $child) {
 167                 if ($child->real_name == $name) {
 168                     return $child;
 169                 }
 170             }
 171         } else {
 172             foreach ($this->children as $child) {
 173                 if ($child->name == $name) {
 174                     return $child;
 175                 }
 176             }
 177         }
 178         return false;
 179     }
 180
 181     /**
 182      * Removes a child node from this node
 183      *
 184      * @param string $name The name of child to be removed
 185      *
 186      * @return void
 187      */
 188     public function removeChild($name)
 189     {
 190         foreach ($this->children as $key => $child) {
 191             if ($child->name == $name) {
 192                 unset($this->children[$key]);
 193                 break;
 194             }
 195         }
 196     }
 197
 198     /**
 199      * Retrieves the parents for a node
 200      *
 201      * @param bool $self       Whether to include the Node itself in the results
 202      * @param bool $containers Whether to include nodes of type CONTAINER
 203      * @param bool $groups     Whether to include nodes which have $group == true
 204      *
 205      * @return array An array of parent Nodes
 206      */
 207     public function parents($self = false, $containers = false, $groups = false)
 208     {
 209         $parents = array();
 210         if ($self
 211             && ($this->type != Node::CONTAINER || $containers)
 212             && (!$this->is_group || $groups)
 213         ) {
 214             $parents[] = $this;
 215         }
 216         $parent = $this->parent;
 217         while (isset($parent)) {
 218             if (($parent->type != Node::CONTAINER || $containers)
 219                 && (!$parent->is_group || $groups)
 220             ) {
 221                 $parents[] = $parent;
 222             }
 223             $parent = $parent->parent;
 224         }
 225         return $parents;
 226     }
 227
 228     /**
 229      * Returns the actual parent of a node. If used twice on an index or columns
 230      * node, it will return the table and database nodes. The names of the returned
 231      * nodes can be used in SQL queries, etc...
 232      *
 233      * @return Node|false
 234      */
 235     public function realParent()
 236     {
 237         $retval = $this->parents();
 238         if (count($retval) <= 0) {
 239             return false;
 240         }
 241
 242         return $retval[0];
 243     }
 244
 245     /**
 246      * This function checks if the node has children nodes associated with it
 247      *
 248      * @param bool $count_empty_containers Whether to count empty child
 249      *                                     containers as valid children
 250      *
 251      * @return bool Whether the node has child nodes
 252      */
 253     public function hasChildren($count_empty_containers = true)
 254     {
 255         $retval = false;
 256         if ($count_empty_containers) {
 257             if (count($this->children)) {
 258                 $retval = true;
 259             }
 260         } else {
 261             foreach ($this->children as $child) {
 262                 if ($child->type == Node::OBJECT || $child->hasChildren(false)) {
 263                     $retval = true;
 264                     break;
 265                 }
 266             }
 267         }
 268         return $retval;
 269     }
 270
 271     /**
 272      * Returns true if the node has some siblings (other nodes on the same tree
 273      * level, in the same branch), false otherwise.
 274      * The only exception is for nodes on
 275      * the third level of the tree (columns and indexes), for which the function
 276      * always returns true. This is because we want to render the containers
 277      * for these nodes
 278      *
 279      * @return bool
 280      */
 281     public function hasSiblings()
 282     {
 283         $retval = false;
 284         $paths  = $this->getPaths();
 285         if (count($paths['aPath_clean']) > 3) {
 286             $retval = true;
 287             return $retval;
 288         }
 289
 290         foreach ($this->parent->children as $child) {
 291             if ($child !== $this
 292                 && ($child->type == Node::OBJECT || $child->hasChildren(false))
 293             ) {
 294                 $retval = true;
 295                 break;
 296             }
 297         }
 298         return $retval;
 299     }
 300
 301     /**
 302      * Returns the number of child nodes that a node has associated with it
 303      *
 304      * @return int The number of children nodes
 305      */
 306     public function numChildren()
 307     {
 308         $retval = 0;
 309         foreach ($this->children as $child) {
 310             if ($child->type == Node::OBJECT) {
 311                 $retval++;
 312             } else {
 313                 $retval += $child->numChildren();
 314             }
 315         }
 316         return $retval;
 317     }
 318
 319     /**
 320      * Returns the actual path and the virtual paths for a node
 321      * both as clean arrays and base64 encoded strings
 322      *
 323      * @return array
 324      */
 325     public function getPaths()
 326     {
 327         $aPath       = array();
 328         $aPath_clean = array();
 329         foreach ($this->parents(true, true, false) as $parent) {
 330             $aPath[]       = base64_encode($parent->real_name);
 331             $aPath_clean[] = $parent->real_name;
 332         }
 333         $aPath       = implode('.', array_reverse($aPath));
 334         $aPath_clean = array_reverse($aPath_clean);
 335
 336         $vPath       = array();
 337         $vPath_clean = array();
 338         foreach ($this->parents(true, true, true) as $parent) {
 339             $vPath[]       = base64_encode($parent->name);
 340             $vPath_clean[] = $parent->name;
 341         }
 342         $vPath       = implode('.', array_reverse($vPath));
 343         $vPath_clean = array_reverse($vPath_clean);
 344
 345         return array(
 346             'aPath' => $aPath,
 347             'aPath_clean' => $aPath_clean,
 348             'vPath' => $vPath,
 349             'vPath_clean' => $vPath_clean
 350         );
 351     }
 352
 353     /**
 354      * Returns the names of children of type $type present inside this container
 355      * This method is overridden by the Node_Database and Node_Table classes
 356      *
 357      * @param string $type         The type of item we are looking for
 358      *                             ('tables', 'views', etc)
 359      * @param int    $pos          The offset of the list within the results
 360      * @param string $searchClause A string used to filter the results of the query
 361      *
 362      * @return array
 363      */
 364     public function getData($type, $pos, $searchClause = '')
 365     {
 366         $maxItems = $GLOBALS['cfg']['FirstLevelNavigationItems'];
 367         if (!$GLOBALS['cfg']['NavigationTreeEnableGrouping']
 368             || !$GLOBALS['cfg']['ShowDatabasesNavigationAsTree']
 369         ) {
 370             if (isset($GLOBALS['cfg']['Server']['DisableIS'])
 371                 && ! $GLOBALS['cfg']['Server']['DisableIS']
 372             ) {
 373                 $query  = "SELECT `SCHEMA_NAME` ";
 374                 $query .= "FROM `INFORMATION_SCHEMA`.`SCHEMATA` ";
 375                 $query .= $this->_getWhereClause('SCHEMA_NAME', $searchClause);
 376                 $query .= "ORDER BY `SCHEMA_NAME` ";
 377                 $query .= "LIMIT $pos, $maxItems";
 378                 $retval = $GLOBALS['dbi']->fetchResult($query);
 379                 return $retval;
 380             }
 381
 382             if ($GLOBALS['dbs_to_test'] === false) {
 383                 $retval = array();
 384                 $query = "SHOW DATABASES ";
 385                 $query .= $this->_getWhereClause('Database', $searchClause);
 386                 $handle = $GLOBALS['dbi']->tryQuery($query);
 387                 if ($handle === false) {
 388                     return $retval;
 389                 }
 390
 391                 $count = 0;
 392                 if (!$GLOBALS['dbi']->dataSeek($handle, $pos)) {
 393                     return $retval;
 394                 }
 395
 396                 while ($arr = $GLOBALS['dbi']->fetchArray($handle)) {
 397                     if ($count < $maxItems) {
 398                         $retval[] = $arr[0];
 399                         $count++;
 400                     } else {
 401                         break;
 402                     }
 403                 }
 404
 405                 return $retval;
 406             }
 407
 408             $retval = array();
 409             $count = 0;
 410             foreach ($this->_getDatabasesToSearch($searchClause) as $db) {
 411                 $query = "SHOW DATABASES LIKE '" . $db . "'";
 412                 $handle = $GLOBALS['dbi']->tryQuery($query);
 413                 if ($handle === false) {
 414                     continue;
 415                 }
 416
 417                 while ($arr = $GLOBALS['dbi']->fetchArray($handle)) {
 418                     if ($this->_isHideDb($arr[0])) {
 419                         continue;
 420                     }
 421                     if (in_array($arr[0], $retval)) {
 422                         continue;
 423                     }
 424
 425                     if ($pos <= 0 && $count < $maxItems) {
 426                         $retval[] = $arr[0];
 427                         $count++;
 428                     }
 429                     $pos--;
 430                 }
 431             }
 432             sort($retval);
 433             return $retval;
 434         }
 435
 436         $dbSeparator = $GLOBALS['cfg']['NavigationTreeDbSeparator'];
 437         if (isset($GLOBALS['cfg']['Server']['DisableIS'])
 438             && ! $GLOBALS['cfg']['Server']['DisableIS']
 439         ) {
 440             $query  = "SELECT `SCHEMA_NAME` ";
 441             $query .= "FROM `INFORMATION_SCHEMA`.`SCHEMATA`, ";
 442             $query .= "(";
 443             $query .= "SELECT DB_first_level ";
 444             $query .= "FROM ( ";
 445             $query .= "SELECT DISTINCT SUBSTRING_INDEX(SCHEMA_NAME, ";
 446             $query .= "'$dbSeparator', 1) ";
 447             $query .= "DB_first_level ";
 448             $query .= "FROM INFORMATION_SCHEMA.SCHEMATA ";
 449             $query .= $this->_getWhereClause('SCHEMA_NAME', $searchClause);
 450             $query .= ") t ";
 451             $query .= "ORDER BY DB_first_level ASC ";
 452             $query .= "LIMIT $pos, $maxItems";
 453             $query .= ") t2 ";
 454             $query .= $this->_getWhereClause('SCHEMA_NAME', $searchClause);
 455             $query .= "AND 1 = LOCATE(CONCAT(DB_first_level, ";
 456             $query .= "'$dbSeparator'), ";
 457             $query .= "CONCAT(SCHEMA_NAME, ";
 458             $query .= "'$dbSeparator')) ";
 459             $query .= "ORDER BY SCHEMA_NAME ASC";
 460             $retval = $GLOBALS['dbi']->fetchResult($query);
 461             return $retval;
 462         }
 463
 464         if ($GLOBALS['dbs_to_test'] === false) {
 465             $query = "SHOW DATABASES ";
 466             $query .= $this->_getWhereClause('Database', $searchClause);
 467             $handle = $GLOBALS['dbi']->tryQuery($query);
 468             $prefixes = array();
 469             if ($handle !== false) {
 470                 $prefixMap = array();
 471                 $total = $pos + $maxItems;
 472                 while ($arr = $GLOBALS['dbi']->fetchArray($handle)) {
 473                     $prefix = strstr($arr[0], $dbSeparator, true);
 474                     if ($prefix === false) {
 475                         $prefix = $arr[0];
 476                     }
 477                     $prefixMap[$prefix] = 1;
 478                     if (sizeof($prefixMap) == $total) {
 479                         break;
 480                     }
 481                 }
 482                 $prefixes = array_slice(array_keys($prefixMap), $pos);
 483             }
 484
 485             $query = "SHOW DATABASES ";
 486             $query .= $this->_getWhereClause('Database', $searchClause);
 487             $query .= " AND (";
 488             $subClauses = array();
 489             foreach ($prefixes as $prefix) {
 490                 $subClauses[] = " LOCATE('"
 491                     . PMA_Util::sqlAddSlashes($prefix) . $dbSeparator . "', "
 492                     . "CONCAT(`Database`, '" . $dbSeparator . "')) = 1 ";
 493             }
 494             $query .= implode("OR", $subClauses) . ")";
 495             $retval = $GLOBALS['dbi']->fetchResult($query);
 496             return $retval;
 497         }
 498
 499         $retval = array();
 500         $prefixMap = array();
 501         $total = $pos + $maxItems;
 502         foreach ($this->_getDatabasesToSearch($searchClause) as $db) {
 503             $query = "SHOW DATABASES LIKE '" . $db . "'";
 504             $handle = $GLOBALS['dbi']->tryQuery($query);
 505             if ($handle === false) {
 506                 continue;
 507             }
 508
 509             while ($arr = $GLOBALS['dbi']->fetchArray($handle)) {
 510                 if ($this->_isHideDb($arr[0])) {
 511                     continue;
 512                 }
 513                 $prefix = strstr($arr[0], $dbSeparator, true);
 514                 if ($prefix === false) {
 515                     $prefix = $arr[0];
 516                 }
 517                 $prefixMap[$prefix] = 1;
 518                 if (sizeof($prefixMap) == $total) {
 519                     break 2;
 520                 }
 521             }
 522         }
 523         $prefixes = array_slice(array_keys($prefixMap), $pos);
 524
 525         foreach ($this->_getDatabasesToSearch($searchClause) as $db) {
 526             $query = "SHOW DATABASES LIKE '" . $db . "'";
 527             $handle = $GLOBALS['dbi']->tryQuery($query);
 528             if ($handle === false) {
 529                 continue;
 530             }
 531
 532             while ($arr = $GLOBALS['dbi']->fetchArray($handle)) {
 533                 if ($this->_isHideDb($arr[0])) {
 534                     continue;
 535                 }
 536                 if (in_array($arr[0], $retval)) {
 537                     continue;
 538                 }
 539
 540                 foreach ($prefixes as $prefix) {
 541                     $starts_with = strpos(
 542                         $arr[0] . $dbSeparator,
 543                         $prefix . $dbSeparator
 544                     ) === 0;
 545                     if ($starts_with) {
 546                         $retval[] = $arr[0];
 547                         break;
 548                     }
 549                 }
 550             }
 551         }
 552         sort($retval);
 553
 554         return $retval;
 555     }
 556
 557     /**
 558      * Returns the number of children of type $type present inside this container
 559      * This method is overridden by the Node_Database and Node_Table classes
 560      *
 561      * @param string $type         The type of item we are looking for
 562      *                             ('tables', 'views', etc)
 563      * @param string $searchClause A string used to filter the results of the query
 564      *
 565      * @return int
 566      */
 567     public function getPresence($type = '', $searchClause = '')
 568     {
 569         if (!$GLOBALS['cfg']['NavigationTreeEnableGrouping']
 570             || !$GLOBALS['cfg']['ShowDatabasesNavigationAsTree']
 571         ) {
 572             if (isset($GLOBALS['cfg']['Server']['DisableIS'])
 573                 && ! $GLOBALS['cfg']['Server']['DisableIS']
 574             ) {
 575                 $query = "SELECT COUNT(*) ";
 576                 $query .= "FROM INFORMATION_SCHEMA.SCHEMATA ";
 577                 $query .= $this->_getWhereClause('SCHEMA_NAME', $searchClause);
 578                 $retval = (int)$GLOBALS['dbi']->fetchValue($query);
 579                 return $retval;
 580             }
 581
 582             if ($GLOBALS['dbs_to_test'] === false) {
 583                 $query = "SHOW DATABASES ";
 584                 $query .= $this->_getWhereClause('Database', $searchClause);
 585                 $retval = $GLOBALS['dbi']->numRows(
 586                     $GLOBALS['dbi']->tryQuery($query)
 587                 );
 588                 return $retval;
 589             }
 590
 591             $retval = 0;
 592             foreach ($this->_getDatabasesToSearch($searchClause) as $db) {
 593                 $query = "SHOW DATABASES LIKE '" . $db . "'";
 594                 $retval += $GLOBALS['dbi']->numRows(
 595                     $GLOBALS['dbi']->tryQuery($query)
 596                 );
 597             }
 598             return $retval;
 599         }
 600
 601         $dbSeparator = $GLOBALS['cfg']['NavigationTreeDbSeparator'];
 602         if (! $GLOBALS['cfg']['Server']['DisableIS']) {
 603             $query = "SELECT COUNT(*) ";
 604             $query .= "FROM ( ";
 605             $query .= "SELECT DISTINCT SUBSTRING_INDEX(SCHEMA_NAME, ";
 606             $query .= "'$dbSeparator', 1) ";
 607             $query .= "DB_first_level ";
 608             $query .= "FROM INFORMATION_SCHEMA.SCHEMATA ";
 609             $query .= $this->_getWhereClause('SCHEMA_NAME', $searchClause);
 610             $query .= ") t ";
 611             $retval = (int)$GLOBALS['dbi']->fetchValue($query);
 612             return $retval;
 613         }
 614
 615         if ($GLOBALS['dbs_to_test'] !== false) {
 616             $prefixMap = array();
 617             foreach ($this->_getDatabasesToSearch($searchClause) as $db) {
 618                 $query = "SHOW DATABASES LIKE '" . $db . "'";
 619                 $handle = $GLOBALS['dbi']->tryQuery($query);
 620                 if ($handle === false) {
 621                     continue;
 622                 }
 623
 624                 while ($arr = $GLOBALS['dbi']->fetchArray($handle)) {
 625                     if ($this->_isHideDb($arr[0])) {
 626                         continue;
 627                     }
 628                     $prefix = strstr($arr[0], $dbSeparator, true);
 629                     if ($prefix === false) {
 630                         $prefix = $arr[0];
 631                     }
 632                     $prefixMap[$prefix] = 1;
 633                 }
 634             }
 635             $retval = count($prefixMap);
 636             return $retval;
 637         }
 638
 639         $prefixMap = array();
 640         $query = "SHOW DATABASES ";
 641         $query .= $this->_getWhereClause('Database', $searchClause);
 642         $handle = $GLOBALS['dbi']->tryQuery($query);
 643         if ($handle !== false) {
 644             while ($arr = $GLOBALS['dbi']->fetchArray($handle)) {
 645                 $prefix = strstr($arr[0], $dbSeparator, true);
 646                 if ($prefix === false) {
 647                     $prefix = $arr[0];
 648                 }
 649                 $prefixMap[$prefix] = 1;
 650             }
 651         }
 652         $retval = count($prefixMap);
 653
 654         return $retval;
 655     }
 656
 657     /**
 658      * Detemines whether a given database should be hidden according to 'hide_db'
 659      *
 660      * @param string $db database name
 661      *
 662      * @return boolean whether to hide
 663      */
 664     private function _isHideDb($db)
 665     {
 666         if (! empty($GLOBALS['cfg']['Server']['hide_db'])
 667             && preg_match('/' . $GLOBALS['cfg']['Server']['hide_db'] . '/', $db)
 668         ) {
 669             return true;
 670         }
 671         return false;
 672     }
 673
 674     /**
 675      * Get the list of databases for 'SHOW DATABASES LIKE' queries.
 676      * If a search clause is set it gets the highest priority while only_db gets
 677      * the next priority. In case both are empty list of databases determined by
 678      * GRANTs are used
 679      *
 680      * @param string $searchClause search clause
 681      *
 682      * @return array array of databases
 683      */
 684     private function _getDatabasesToSearch($searchClause)
 685     {
 686         if (! empty($searchClause)) {
 687             $databases = array(
 688                 "%" . PMA_Util::sqlAddSlashes($searchClause, true) . "%"
 689             );
 690         } elseif (! empty($GLOBALS['cfg']['Server']['only_db'])) {
 691             $databases = $GLOBALS['cfg']['Server']['only_db'];
 692         } elseif (! empty($GLOBALS['dbs_to_test'])) {
 693             $databases = $GLOBALS['dbs_to_test'];
 694         }
 695         sort($databases);
 696         return $databases;
 697     }
 698
 699     /**
 700      * Returns the WHERE clause depending on the $searchClause parameter
 701      * and the hide_db directive
 702      *
 703      * @param string $columnName   Column name of the column having database names
 704      * @param string $searchClause A string used to filter the results of the query
 705      *
 706      * @return string
 707      */
 708     private function _getWhereClause($columnName, $searchClause = '')
 709     {
 710         $whereClause = "WHERE TRUE ";
 711         if (! empty($searchClause)) {
 712             $whereClause .= "AND " . PMA_Util::backquote($columnName) . " LIKE '%";
 713             $whereClause .= PMA_Util::sqlAddSlashes(
 714                 $searchClause, true
 715             );
 716             $whereClause .= "%' ";
 717         }
 718
 719         if (! empty($GLOBALS['cfg']['Server']['hide_db'])) {
 720             $whereClause .= "AND " . PMA_Util::backquote($columnName)
 721                 . " NOT REGEXP '" . $GLOBALS['cfg']['Server']['hide_db'] . "' ";
 722         }
 723
 724         if (! empty($GLOBALS['cfg']['Server']['only_db'])) {
 725             if (is_string($GLOBALS['cfg']['Server']['only_db'])) {
 726                 $GLOBALS['cfg']['Server']['only_db'] = array(
 727                     $GLOBALS['cfg']['Server']['only_db']
 728                 );
 729             }
 730             $whereClause .= "AND (";
 731             $subClauses = array();
 732             foreach ($GLOBALS['cfg']['Server']['only_db'] as $each_only_db) {
 733                 $subClauses[] = " " . PMA_Util::backquote($columnName) . " LIKE '"
 734                     . $each_only_db . "' ";
 735             }
 736             $whereClause .= implode("OR", $subClauses) . ")";
 737         }
 738         return $whereClause;
 739     }
 740
 741     /**
 742      * Returns HTML for control buttons displayed infront of a node
 743      *
 744      * @return String HTML for control buttons
 745      */
 746     public function getHtmlForControlButtons()
 747     {
 748         return '';
 749     }
 750
 751     /**
 752      * Returns CSS classes for a node
 753      *
 754      * @param boolean $match Whether the node matched loaded tree
 755      *
 756      * @return String with html classes.
 757      */
 758     public function getCssClasses($match)
 759     {
 760         if (! $GLOBALS['cfg']['NavigationTreeEnableExpansion']
 761         ) {
 762             return '';
 763         }
 764
 765         $result = array('expander');
 766
 767         if ($this->is_group || $match) {
 768             $result[] = 'loaded';
 769         }
 770         if ($this->type == Node::CONTAINER) {
 771             $result[] = 'container';
 772         }
 773
 774         return implode(' ', $result);
 775     }
 776
 777     /**
 778      * Returns icon for the node
 779      *
 780      * @param boolean $match Whether the node matched loaded tree
 781      *
 782      * @return String with image name
 783      */
 784     public function getIcon($match)
 785     {
 786         if (! $GLOBALS['cfg']['NavigationTreeEnableExpansion']
 787         ) {
 788             return '';
 789         } elseif ($match && ! $this->is_group) {
 790             $this->visible = true;
 791             return PMA_Util::getImage('b_minus.png');
 792         } else {
 793             return PMA_Util::getImage('b_plus.png', __('Expand/Collapse'));
 794         }
 795     }
 796
 797     /**
 798      * Gets the count of hidden elements for each database
 799      *
 800      * @return array array containing the count of hidden elements for each database
 801      */
 802     public function getNavigationHidingData()
 803     {
 804         $cfgRelation = PMA_getRelationsParam();
 805         if ($cfgRelation['navwork']) {
 806             $navTable = PMA_Util::backquote($cfgRelation['db'])
 807             . "." . PMA_Util::backquote($cfgRelation['navigationhiding']);
 808             $sqlQuery = "SELECT `db_name`, COUNT(*) AS `count` FROM " . $navTable
 809             . " WHERE `username`='"
 810                 . PMA_Util::sqlAddSlashes($GLOBALS['cfg']['Server']['user']) . "'"
 811                     . " GROUP BY `db_name`";
 812             $counts = $GLOBALS['dbi']->fetchResult(
 813                 $sqlQuery, 'db_name', 'count', $GLOBALS['controllink']
 814             );
 815             return $counts;
 816         }
 817         return null;
 818     }
 819 }