lib/pgsqlschema.php

   1 <?php
   2 /**
   3  * StatusNet, the distributed open-source microblogging tool
   4  *
   5  * Database schema utilities
   6  *
   7  * PHP version 5
   8  *
   9  * LICENCE: This program is free software: you can redistribute it and/or modify
  10  * it under the terms of the GNU Affero General Public License as published by
  11  * the Free Software Foundation, either version 3 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU Affero General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Affero General Public License
  20  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21  *
  22  * @category  Database
  23  * @package   StatusNet
  24  * @author    Evan Prodromou <evan@status.net>
  25  * @copyright 2009 StatusNet, Inc.
  26  * @license   http://www.fsf.org/licensing/licenses/agpl-3.0.html GNU Affero General Public License version 3.0
  27  * @link      http://status.net/
  28  */
  29
  30 if (!defined('STATUSNET')) {
  31     exit(1);
  32 }
  33
  34 /**
  35  * Class representing the database schema
  36  *
  37  * A class representing the database schema. Can be used to
  38  * manipulate the schema -- especially for plugins and upgrade
  39  * utilities.
  40  *
  41  * @category Database
  42  * @package  StatusNet
  43  * @author   Evan Prodromou <evan@status.net>
  44  * @author   Brenda Wallace <shiny@cpan.org>
  45  * @license  http://www.fsf.org/licensing/licenses/agpl-3.0.html GNU Affero General Public License version 3.0
  46  * @link     http://status.net/
  47  */
  48
  49 class PgsqlSchema extends Schema
  50 {
  51
  52     /**
  53      * Returns a TableDef object for the table
  54      * in the schema with the given name.
  55      *
  56      * Throws an exception if the table is not found.
  57      *
  58      * @param string $name Name of the table to get
  59      *
  60      * @return TableDef tabledef for that table.
  61      */
  62
  63     public function getTableDef($name)
  64     {
  65         $res = $this->conn->query("SELECT *, column_default as default, is_nullable as Null,
  66         udt_name as Type, column_name AS Field from INFORMATION_SCHEMA.COLUMNS where table_name = '$name'");
  67
  68         if (PEAR::isError($res)) {
  69             throw new Exception($res->getMessage());
  70         }
  71
  72         $td = new TableDef();
  73
  74         $td->name    = $name;
  75         $td->columns = array();
  76
  77         if ($res->numRows() == 0 ) {
  78           throw new Exception('no such table'); //pretend to be the msyql error. yeah, this sucks.
  79         }
  80         $row = array();
  81
  82         while ($res->fetchInto($row, DB_FETCHMODE_ASSOC)) {
  83             $cd = new ColumnDef();
  84
  85             $cd->name = $row['field'];
  86
  87             $packed = $row['type'];
  88
  89             if (preg_match('/^(\w+)\((\d+)\)$/', $packed, $match)) {
  90                 $cd->type = $match[1];
  91                 $cd->size = $match[2];
  92             } else {
  93                 $cd->type = $packed;
  94             }
  95
  96             $cd->nullable = ($row['null'] == 'YES') ? true : false;
  97             $cd->key      = $row['Key'];
  98             $cd->default  = $row['default'];
  99             $cd->extra    = $row['Extra'];
 100
 101             $td->columns[] = $cd;
 102         }
 103         return $td;
 104     }
 105
 106     /**
 107      * Gets a ColumnDef object for a single column.
 108      *
 109      * Throws an exception if the table is not found.
 110      *
 111      * @param string $table  name of the table
 112      * @param string $column name of the column
 113      *
 114      * @return ColumnDef definition of the column or null
 115      *                   if not found.
 116      */
 117
 118     public function getColumnDef($table, $column)
 119     {
 120         $td = $this->getTableDef($table);
 121
 122         foreach ($td->columns as $cd) {
 123             if ($cd->name == $column) {
 124                 return $cd;
 125             }
 126         }
 127
 128         return null;
 129     }
 130
 131     /**
 132      * Creates a table with the given names and columns.
 133      *
 134      * @param string $name    Name of the table
 135      * @param array  $columns Array of ColumnDef objects
 136      *                        for new table.
 137      *
 138      * @return boolean success flag
 139      */
 140
 141     public function createTable($name, $columns)
 142     {
 143         $uniques = array();
 144         $primary = array();
 145         $indices = array();
 146
 147         $sql = "CREATE TABLE $name (\n";
 148
 149         for ($i = 0; $i < count($columns); $i++) {
 150
 151             $cd =& $columns[$i];
 152
 153             if ($i > 0) {
 154                 $sql .= ",\n";
 155             }
 156
 157             $sql .= $this->_columnSql($cd);
 158             switch ($cd->key) {
 159             case 'UNI':
 160                 $uniques[] = $cd->name;
 161                 break;
 162             case 'PRI':
 163                 $primary[] = $cd->name;
 164                 break;
 165             case 'MUL':
 166                 $indices[] = $cd->name;
 167                 break;
 168             }
 169         }
 170
 171         if (count($primary) > 0) { // it really should be...
 172             $sql .= ",\n primary key (" . implode(',', $primary) . ")";
 173         }
 174
 175         $sql .= "); ";
 176
 177
 178         foreach ($uniques as $u) {
 179             $sql .= "\n CREATE index {$name}_{$u}_idx ON {$name} ($u); ";
 180         }
 181
 182         foreach ($indices as $i) {
 183             $sql .= "CREATE index {$name}_{$i}_idx on {$name} ($i)";
 184         }
 185         $res = $this->conn->query($sql);
 186
 187         if (PEAR::isError($res)) {
 188             throw new Exception($res->getMessage(). ' SQL was '. $sql);
 189         }
 190
 191         return true;
 192     }
 193
 194     /**
 195      * Drops a table from the schema
 196      *
 197      * Throws an exception if the table is not found.
 198      *
 199      * @param string $name Name of the table to drop
 200      *
 201      * @return boolean success flag
 202      */
 203
 204     public function dropTable($name)
 205     {
 206         $res = $this->conn->query("DROP TABLE $name");
 207
 208         if (PEAR::isError($res)) {
 209             throw new Exception($res->getMessage());
 210         }
 211
 212         return true;
 213     }
 214
 215     /**
 216      * Translate the (mostly) mysql-ish column types into somethings more standard
 217      * @param string column type
 218      *
 219      * @return string postgres happy column type
 220      */
 221     private function _columnTypeTranslation($type) {
 222       $map = array(
 223       'datetime' => 'timestamp',
 224       );
 225       if(!empty($map[$type])) {
 226         return $map[$type];
 227       }
 228       return $type;
 229     }
 230
 231     /**
 232      * Adds an index to a table.
 233      *
 234      * If no name is provided, a name will be made up based
 235      * on the table name and column names.
 236      *
 237      * Throws an exception on database error, esp. if the table
 238      * does not exist.
 239      *
 240      * @param string $table       Name of the table
 241      * @param array  $columnNames Name of columns to index
 242      * @param string $name        (Optional) name of the index
 243      *
 244      * @return boolean success flag
 245      */
 246
 247     public function createIndex($table, $columnNames, $name=null)
 248     {
 249         if (!is_array($columnNames)) {
 250             $columnNames = array($columnNames);
 251         }
 252
 253         if (empty($name)) {
 254             $name = "$table_".implode("_", $columnNames)."_idx";
 255         }
 256
 257         $res = $this->conn->query("ALTER TABLE $table ".
 258                                    "ADD INDEX $name (".
 259                                    implode(",", $columnNames).")");
 260
 261         if (PEAR::isError($res)) {
 262             throw new Exception($res->getMessage());
 263         }
 264
 265         return true;
 266     }
 267
 268     /**
 269      * Drops a named index from a table.
 270      *
 271      * @param string $table name of the table the index is on.
 272      * @param string $name  name of the index
 273      *
 274      * @return boolean success flag
 275      */
 276
 277     public function dropIndex($table, $name)
 278     {
 279         $res = $this->conn->query("ALTER TABLE $table DROP INDEX $name");
 280
 281         if (PEAR::isError($res)) {
 282             throw new Exception($res->getMessage());
 283         }
 284
 285         return true;
 286     }
 287
 288     /**
 289      * Adds a column to a table
 290      *
 291      * @param string    $table     name of the table
 292      * @param ColumnDef $columndef Definition of the new
 293      *                             column.
 294      *
 295      * @return boolean success flag
 296      */
 297
 298     public function addColumn($table, $columndef)
 299     {
 300         $sql = "ALTER TABLE $table ADD COLUMN " . $this->_columnSql($columndef);
 301
 302         $res = $this->conn->query($sql);
 303
 304         if (PEAR::isError($res)) {
 305             throw new Exception($res->getMessage());
 306         }
 307
 308         return true;
 309     }
 310
 311     /**
 312      * Modifies a column in the schema.
 313      *
 314      * The name must match an existing column and table.
 315      *
 316      * @param string    $table     name of the table
 317      * @param ColumnDef $columndef new definition of the column.
 318      *
 319      * @return boolean success flag
 320      */
 321
 322     public function modifyColumn($table, $columndef)
 323     {
 324         $sql = "ALTER TABLE $table MODIFY COLUMN " .
 325           $this->_columnSql($columndef);
 326
 327         $res = $this->conn->query($sql);
 328
 329         if (PEAR::isError($res)) {
 330             throw new Exception($res->getMessage());
 331         }
 332
 333         return true;
 334     }
 335
 336     /**
 337      * Drops a column from a table
 338      *
 339      * The name must match an existing column.
 340      *
 341      * @param string $table      name of the table
 342      * @param string $columnName name of the column to drop
 343      *
 344      * @return boolean success flag
 345      */
 346
 347     public function dropColumn($table, $columnName)
 348     {
 349         $sql = "ALTER TABLE $table DROP COLUMN $columnName";
 350
 351         $res = $this->conn->query($sql);
 352
 353         if (PEAR::isError($res)) {
 354             throw new Exception($res->getMessage());
 355         }
 356
 357         return true;
 358     }
 359
 360     /**
 361      * Ensures that a table exists with the given
 362      * name and the given column definitions.
 363      *
 364      * If the table does not yet exist, it will
 365      * create the table. If it does exist, it will
 366      * alter the table to match the column definitions.
 367      *
 368      * @param string $tableName name of the table
 369      * @param array  $columns   array of ColumnDef
 370      *                          objects for the table
 371      *
 372      * @return boolean success flag
 373      */
 374
 375     public function ensureTable($tableName, $columns)
 376     {
 377         // XXX: DB engine portability -> toilet
 378
 379         try {
 380             $td = $this->getTableDef($tableName);
 381
 382         } catch (Exception $e) {
 383             if (preg_match('/no such table/', $e->getMessage())) {
 384                 return $this->createTable($tableName, $columns);
 385             } else {
 386                 throw $e;
 387             }
 388         }
 389
 390         $cur = $this->_names($td->columns);
 391         $new = $this->_names($columns);
 392
 393         $toadd  = array_diff($new, $cur);
 394         $todrop = array_diff($cur, $new);
 395         $same   = array_intersect($new, $cur);
 396         $tomod  = array();
 397         foreach ($same as $m) {
 398             $curCol = $this->_byName($td->columns, $m);
 399             $newCol = $this->_byName($columns, $m);
 400
 401
 402             if (!$newCol->equals($curCol)) {
 403             // BIG GIANT TODO!
 404             // stop it detecting different types and trying to modify on every page request
 405 //                 $tomod[] = $newCol->name;
 406             }
 407         }
 408         if (count($toadd) + count($todrop) + count($tomod) == 0) {
 409             // nothing to do
 410             return true;
 411         }
 412
 413         // For efficiency, we want this all in one
 414         // query, instead of using our methods.
 415
 416         $phrase = array();
 417
 418         foreach ($toadd as $columnName) {
 419             $cd = $this->_byName($columns, $columnName);
 420
 421             $phrase[] = 'ADD COLUMN ' . $this->_columnSql($cd);
 422         }
 423
 424         foreach ($todrop as $columnName) {
 425             $phrase[] = 'DROP COLUMN ' . $columnName;
 426         }
 427
 428         foreach ($tomod as $columnName) {
 429             $cd = $this->_byName($columns, $columnName);
 430
 431             $phrase[] = 'MODIFY COLUMN ' . $this->_columnSql($cd);
 432         }
 433
 434         $sql = 'ALTER TABLE ' . $tableName . ' ' . implode(', ', $phrase);
 435         $res = $this->conn->query($sql);
 436
 437         if (PEAR::isError($res)) {
 438             throw new Exception($res->getMessage());
 439         }
 440
 441         return true;
 442     }
 443
 444     /**
 445      * Returns the array of names from an array of
 446      * ColumnDef objects.
 447      *
 448      * @param array $cds array of ColumnDef objects
 449      *
 450      * @return array strings for name values
 451      */
 452
 453     private function _names($cds)
 454     {
 455         $names = array();
 456
 457         foreach ($cds as $cd) {
 458             $names[] = $cd->name;
 459         }
 460
 461         return $names;
 462     }
 463
 464     /**
 465      * Get a ColumnDef from an array matching
 466      * name.
 467      *
 468      * @param array  $cds  Array of ColumnDef objects
 469      * @param string $name Name of the column
 470      *
 471      * @return ColumnDef matching item or null if no match.
 472      */
 473
 474     private function _byName($cds, $name)
 475     {
 476         foreach ($cds as $cd) {
 477             if ($cd->name == $name) {
 478                 return $cd;
 479             }
 480         }
 481
 482         return null;
 483     }
 484
 485     /**
 486      * Return the proper SQL for creating or
 487      * altering a column.
 488      *
 489      * Appropriate for use in CREATE TABLE or
 490      * ALTER TABLE statements.
 491      *
 492      * @param ColumnDef $cd column to create
 493      *
 494      * @return string correct SQL for that column
 495      */
 496     private function _columnSql($cd)
 497     {
 498         $sql = "{$cd->name} ";
 499         $type = $this->_columnTypeTranslation($cd->type);
 500
 501         //handle those mysql enum fields that postgres doesn't support
 502         if (preg_match('!^enum!', $type)) {
 503           $allowed_values = preg_replace('!^enum!', '', $type);
 504           $sql .= " text check ({$cd->name} in $allowed_values)";
 505           return $sql;
 506         }
 507         if (!empty($cd->auto_increment)) {
 508           $type = 'serial';
 509         }
 510
 511         if (!empty($cd->size)) {
 512             $sql .= "{$type}({$cd->size}) ";
 513         } else {
 514             $sql .= "{$type} ";
 515         }
 516
 517         if (!empty($cd->default)) {
 518             $sql .= "default {$cd->default} ";
 519         } else {
 520             $sql .= ($cd->nullable) ? "null " : "not null ";
 521         }
 522
 523         if (!empty($cd->extra)) {
 524             $sql .= "{$cd->extra} ";
 525         }
 526
 527         return $sql;
 528     }
 529 }