includes/libs/rdbms/database/DatabaseDomain.php

   1 <?php
   2 /**
   3  * This program is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation; either version 2 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along
  14  * with this program; if not, write to the Free Software Foundation, Inc.,
  15  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  16  * http://www.gnu.org/copyleft/gpl.html
  17  *
  18  * @file
  19  * @ingroup Database
  20  */
  21 namespace Wikimedia\Rdbms;
  22
  23 use InvalidArgumentException;
  24
  25 /**
  26  * Class to handle database/prefix specification for IDatabase domains
  27  */
  28 class DatabaseDomain {
  29         /** @var string|null */
  30         private $database;
  31         /** @var string|null */
  32         private $schema;
  33         /** @var string */
  34         private $prefix;
  35
  36         /** @var string Cache of convertToString() */
  37         private $equivalentString;
  38
  39         /**
  40          * @param string|null $database Database name
  41          * @param string|null $schema Schema name
  42          * @param string $prefix Table prefix
  43          */
  44         public function __construct( $database, $schema, $prefix ) {
  45                 if ( $database !== null && ( !is_string( $database ) || !strlen( $database ) ) ) {
  46                         throw new InvalidArgumentException( "Database must be null or a non-empty string." );
  47                 }
  48                 $this->database = $database;
  49                 if ( $schema !== null && ( !is_string( $schema ) || !strlen( $schema ) ) ) {
  50                         throw new InvalidArgumentException( "Schema must be null or a non-empty string." );
  51                 }
  52                 $this->schema = $schema;
  53                 if ( !is_string( $prefix ) ) {
  54                         throw new InvalidArgumentException( "Prefix must be a string." );
  55                 }
  56                 $this->prefix = $prefix;
  57         }
  58
  59         /**
  60          * @param DatabaseDomain|string $domain Result of DatabaseDomain::toString()
  61          * @return DatabaseDomain
  62          */
  63         public static function newFromId( $domain ) {
  64                 if ( $domain instanceof self ) {
  65                         return $domain;
  66                 }
  67
  68                 $parts = array_map( [ __CLASS__, 'decode' ], explode( '-', $domain ) );
  69
  70                 $schema = null;
  71                 $prefix = '';
  72
  73                 if ( count( $parts ) == 1 ) {
  74                         $database = $parts[0];
  75                 } elseif ( count( $parts ) == 2 ) {
  76                         list( $database, $prefix ) = $parts;
  77                 } elseif ( count( $parts ) == 3 ) {
  78                         list( $database, $schema, $prefix ) = $parts;
  79                 } else {
  80                         throw new InvalidArgumentException( "Domain has too few or too many parts." );
  81                 }
  82
  83                 if ( $database === '' ) {
  84                         $database = null;
  85                 }
  86
  87                 return new self( $database, $schema, $prefix );
  88         }
  89
  90         /**
  91          * @return DatabaseDomain
  92          */
  93         public static function newUnspecified() {
  94                 return new self( null, null, '' );
  95         }
  96
  97         /**
  98          * @param DatabaseDomain|string $other
  99          * @return bool
 100          */
 101         public function equals( $other ) {
 102                 if ( $other instanceof DatabaseDomain ) {
 103                         return (
 104                                 $this->database === $other->database &&
 105                                 $this->schema === $other->schema &&
 106                                 $this->prefix === $other->prefix
 107                         );
 108                 }
 109
 110                 return ( $this->getId() === $other );
 111         }
 112
 113         /**
 114          * @return string|null Database name
 115          */
 116         public function getDatabase() {
 117                 return $this->database;
 118         }
 119
 120         /**
 121          * @return string|null Database schema
 122          */
 123         public function getSchema() {
 124                 return $this->schema;
 125         }
 126
 127         /**
 128          * @return string Table prefix
 129          */
 130         public function getTablePrefix() {
 131                 return $this->prefix;
 132         }
 133
 134         /**
 135          * @return string
 136          */
 137         public function getId() {
 138                 if ( $this->equivalentString === null ) {
 139                         $this->equivalentString = $this->convertToString();
 140                 }
 141
 142                 return $this->equivalentString;
 143         }
 144
 145         /**
 146          * @return string
 147          */
 148         private function convertToString() {
 149                 $parts = [ $this->database ];
 150                 if ( $this->schema !== null ) {
 151                         $parts[] = $this->schema;
 152                 }
 153                 if ( $this->prefix != '' ) {
 154                         $parts[] = $this->prefix;
 155                 }
 156
 157                 return implode( '-', array_map( [ __CLASS__, 'encode' ], $parts ) );
 158         }
 159
 160         private static function encode( $decoded ) {
 161                 $encoded = '';
 162
 163                 $length = strlen( $decoded );
 164                 for ( $i = 0; $i < $length; ++$i ) {
 165                         $char = $decoded[$i];
 166                         if ( $char === '-' ) {
 167                                 $encoded .= '?h';
 168                         } elseif ( $char === '?' ) {
 169                                 $encoded .= '??';
 170                         } else {
 171                                 $encoded .= $char;
 172                         }
 173                 }
 174
 175                 return $encoded;
 176         }
 177
 178         private static function decode( $encoded ) {
 179                 $decoded = '';
 180
 181                 $length = strlen( $encoded );
 182                 for ( $i = 0; $i < $length; ++$i ) {
 183                         $char = $encoded[$i];
 184                         if ( $char === '?' ) {
 185                                 $nextChar = isset( $encoded[$i + 1] ) ? $encoded[$i + 1] : null;
 186                                 if ( $nextChar === 'h' ) {
 187                                         $decoded .= '-';
 188                                         ++$i;
 189                                 } elseif ( $nextChar === '?' ) {
 190                                         $decoded .= '?';
 191                                         ++$i;
 192                                 } else {
 193                                         $decoded .= $char;
 194                                 }
 195                         } else {
 196                                 $decoded .= $char;
 197                         }
 198                 }
 199
 200                 return $decoded;
 201         }
 202
 203         /**
 204          * @return string
 205          */
 206         function __toString() {
 207                 return $this->getId();
 208         }
 209 }