lib/schema.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   Brion Vibber <brion@status.net>
  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 Schema
  50 {
  51     static $_static = null;
  52     protected $conn = null;
  53
  54     /**
  55      * Constructor. Only run once for singleton object.
  56      */
  57
  58     protected function __construct($conn = null)
  59     {
  60         if (is_null($conn)) {
  61             // XXX: there should be an easier way to do this.
  62             $user = new User();
  63             $conn = $user->getDatabaseConnection();
  64             $user->free();
  65             unset($user);
  66         }
  67
  68         $this->conn = $conn;
  69     }
  70
  71     /**
  72      * Main public entry point. Use this to get
  73      * the schema object.
  74      *
  75      * @return Schema the Schema object for the connection
  76      */
  77
  78     static function get($conn = null)
  79     {
  80         if (is_null($conn)) {
  81             $key = 'default';
  82         } else {
  83             $key = md5(serialize($conn->dsn));
  84         }
  85
  86         $type = common_config('db', 'type');
  87         if (empty(self::$_static[$key])) {
  88             $schemaClass = ucfirst($type).'Schema';
  89             self::$_static[$key] = new $schemaClass($conn);
  90         }
  91         return self::$_static[$key];
  92     }
  93
  94     /**
  95      * Gets a ColumnDef object for a single column.
  96      *
  97      * Throws an exception if the table is not found.
  98      *
  99      * @param string $table  name of the table
 100      * @param string $column name of the column
 101      *
 102      * @return ColumnDef definition of the column or null
 103      *                   if not found.
 104      */
 105
 106     public function getColumnDef($table, $column)
 107     {
 108         $td = $this->getTableDef($table);
 109
 110         foreach ($td->columns as $cd) {
 111             if ($cd->name == $column) {
 112                 return $cd;
 113             }
 114         }
 115
 116         return null;
 117     }
 118
 119     /**
 120      * Creates a table with the given names and columns.
 121      *
 122      * @param string $tableName    Name of the table
 123      * @param array  $def          Table definition array listing fields and indexes.
 124      *
 125      * @return boolean success flag
 126      */
 127
 128     public function createTable($tableName, $def)
 129     {
 130         $statements = $this->buildCreateTable($tableName, $def);
 131         return $this->runSqlSet($statements);
 132     }
 133
 134     /**
 135      * Build a set of SQL statements to create a table with the given
 136      * name and columns.
 137      *
 138      * @param string $name    Name of the table
 139      * @param array  $def     Table definition array
 140      *
 141      * @return boolean success flag
 142      */
 143     public function buildCreateTable($name, $def)
 144     {
 145         $def = $this->validateDef($name, $def);
 146         $def = $this->filterDef($def);
 147         $sql = array();
 148
 149         foreach ($def['fields'] as $col => $colDef) {
 150             $this->appendColumnDef($sql, $col, $colDef);
 151         }
 152
 153         // Primary, unique, and foreign keys are constraints, so go within
 154         // the CREATE TABLE statement normally.
 155         if (!empty($def['primary key'])) {
 156             $this->appendPrimaryKeyDef($sql, $def['primary key']);
 157         }
 158
 159         if (!empty($def['unique keys'])) {
 160             foreach ($def['unique keys'] as $col => $colDef) {
 161                 $this->appendUniqueKeyDef($sql, $col, $colDef);
 162             }
 163         }
 164
 165         if (!empty($def['foreign keys'])) {
 166             foreach ($def['foreign keys'] as $keyName => $keyDef) {
 167                 $this->appendForeignKeyDef($sql, $keyName, $keyDef);
 168             }
 169         }
 170
 171         // Multi-value indexes are advisory and for best portability
 172         // should be created as separate statements.
 173         $statements = array();
 174         $statements[] = $this->startCreateTable($name, $def) . "\n" .
 175                         implode($sql, ",\n") . "\n" .
 176                         $this->endCreateTable($name, $def);
 177         if (!empty($def['indexes'])) {
 178             foreach ($def['indexes'] as $col => $colDef) {
 179                 $this->appendCreateIndex($statements, $name, $col, $colDef);
 180             }
 181         }
 182
 183         return $statements;
 184     }
 185
 186     /**
 187      * Set up a 'create table' SQL statement.
 188      *
 189      * @param string $name table name
 190      * @param array $def table definition
 191      * @param $string
 192      */
 193     function startCreateTable($name, array $def)
 194     {
 195         return 'CREATE TABLE ' . $this->quoteIdentifier($name)  . ' (';
 196     }
 197
 198     /**
 199      * Close out a 'create table' SQL statement.
 200      *
 201      * @param string $name table name
 202      * @param array $def table definition
 203      * @return string
 204      */
 205     function endCreateTable($name, array $def)
 206     {
 207         return ')';
 208     }
 209
 210     /**
 211      * Append an SQL fragment with a column definition in a CREATE TABLE statement.
 212      *
 213      * @param array $sql
 214      * @param string $name
 215      * @param array $def
 216      */
 217     function appendColumnDef(array &$sql, $name, array $def)
 218     {
 219         $sql[] = "$name " . $this->columnSql($def);
 220     }
 221
 222     /**
 223      * Append an SQL fragment with a constraint definition for a primary
 224      * key in a CREATE TABLE statement.
 225      *
 226      * @param array $sql
 227      * @param array $def
 228      */
 229     function appendPrimaryKeyDef(array &$sql, array $def)
 230     {
 231         $sql[] = "PRIMARY KEY " . $this->buildIndexList($def);
 232     }
 233
 234     /**
 235      * Append an SQL fragment with a constraint definition for a unique
 236      * key in a CREATE TABLE statement.
 237      *
 238      * @param array $sql
 239      * @param string $name
 240      * @param array $def
 241      */
 242     function appendUniqueKeyDef(array &$sql, $name, array $def)
 243     {
 244         $sql[] = "CONSTRAINT $name UNIQUE " . $this->buildIndexList($def);
 245     }
 246
 247     /**
 248      * Append an SQL fragment with a constraint definition for a foreign
 249      * key in a CREATE TABLE statement.
 250      *
 251      * @param array $sql
 252      * @param string $name
 253      * @param array $def
 254      */
 255     function appendForeignKeyDef(array &$sql, $name, array $def)
 256     {
 257         if (count($def) != 2) {
 258             throw new Exception("Invalid foreign key def for $name: " . var_export($def, true));
 259         }
 260         list($refTable, $map) = $def;
 261         $srcCols = array_keys($map);
 262         $refCols = array_values($map);
 263         $sql[] = "CONSTRAINT $name FOREIGN KEY " .
 264                  $this->buildIndexList($srcCols) .
 265                  " REFERENCES " .
 266                  $this->quoteIdentifier($refTable) .
 267                  " " .
 268                  $this->buildIndexList($refCols);
 269     }
 270
 271     /**
 272      * Append an SQL statement with an index definition for an advisory
 273      * index over one or more columns on a table.
 274      *
 275      * @param array $statements
 276      * @param string $table
 277      * @param string $name
 278      * @param array $def
 279      */
 280     function appendCreateIndex(array &$statements, $table, $name, array $def)
 281     {
 282         $statements[] = "CREATE INDEX $name ON $table " . $this->buildIndexList($def);
 283     }
 284
 285     /**
 286      * Append an SQL statement to drop an index from a table.
 287      *
 288      * @param array $statements
 289      * @param string $table
 290      * @param string $name
 291      * @param array $def
 292      */
 293     function appendDropIndex(array &$statements, $table, $name)
 294     {
 295         $statements[] = "DROP INDEX $name ON " . $this->quoteIdentifier($table);
 296     }
 297
 298     function buildIndexList(array $def)
 299     {
 300         // @fixme
 301         return '(' . implode(',', array_map(array($this, 'buildIndexItem'), $def)) . ')';
 302     }
 303
 304     function buildIndexItem($def)
 305     {
 306         if (is_array($def)) {
 307             list($name, $size) = $def;
 308             return $this->quoteIdentifier($name) . '(' . intval($size) . ')';
 309         }
 310         return $this->quoteIdentifier($def);
 311     }
 312
 313     /**
 314      * Drops a table from the schema
 315      *
 316      * Throws an exception if the table is not found.
 317      *
 318      * @param string $name Name of the table to drop
 319      *
 320      * @return boolean success flag
 321      */
 322
 323     public function dropTable($name)
 324     {
 325         $res = $this->conn->query("DROP TABLE $name");
 326
 327         if (PEAR::isError($res)) {
 328             throw new Exception($res->getMessage());
 329         }
 330
 331         return true;
 332     }
 333
 334     /**
 335      * Adds an index to a table.
 336      *
 337      * If no name is provided, a name will be made up based
 338      * on the table name and column names.
 339      *
 340      * Throws an exception on database error, esp. if the table
 341      * does not exist.
 342      *
 343      * @param string $table       Name of the table
 344      * @param array  $columnNames Name of columns to index
 345      * @param string $name        (Optional) name of the index
 346      *
 347      * @return boolean success flag
 348      */
 349
 350     public function createIndex($table, $columnNames, $name=null)
 351     {
 352         if (!is_array($columnNames)) {
 353             $columnNames = array($columnNames);
 354         }
 355
 356         if (empty($name)) {
 357             $name = "{$table}_".implode("_", $columnNames)."_idx";
 358         }
 359
 360         $res = $this->conn->query("ALTER TABLE $table ".
 361                                    "ADD INDEX $name (".
 362                                    implode(",", $columnNames).")");
 363
 364         if (PEAR::isError($res)) {
 365             throw new Exception($res->getMessage());
 366         }
 367
 368         return true;
 369     }
 370
 371     /**
 372      * Drops a named index from a table.
 373      *
 374      * @param string $table name of the table the index is on.
 375      * @param string $name  name of the index
 376      *
 377      * @return boolean success flag
 378      */
 379
 380     public function dropIndex($table, $name)
 381     {
 382         $res = $this->conn->query("ALTER TABLE $table DROP INDEX $name");
 383
 384         if (PEAR::isError($res)) {
 385             throw new Exception($res->getMessage());
 386         }
 387
 388         return true;
 389     }
 390
 391     /**
 392      * Adds a column to a table
 393      *
 394      * @param string    $table     name of the table
 395      * @param ColumnDef $columndef Definition of the new
 396      *                             column.
 397      *
 398      * @return boolean success flag
 399      */
 400
 401     public function addColumn($table, $columndef)
 402     {
 403         $sql = "ALTER TABLE $table ADD COLUMN " . $this->_columnSql($columndef);
 404
 405         $res = $this->conn->query($sql);
 406
 407         if (PEAR::isError($res)) {
 408             throw new Exception($res->getMessage());
 409         }
 410
 411         return true;
 412     }
 413
 414     /**
 415      * Modifies a column in the schema.
 416      *
 417      * The name must match an existing column and table.
 418      *
 419      * @param string    $table     name of the table
 420      * @param ColumnDef $columndef new definition of the column.
 421      *
 422      * @return boolean success flag
 423      */
 424
 425     public function modifyColumn($table, $columndef)
 426     {
 427         $sql = "ALTER TABLE $table MODIFY COLUMN " .
 428           $this->_columnSql($columndef);
 429
 430         $res = $this->conn->query($sql);
 431
 432         if (PEAR::isError($res)) {
 433             throw new Exception($res->getMessage());
 434         }
 435
 436         return true;
 437     }
 438
 439     /**
 440      * Drops a column from a table
 441      *
 442      * The name must match an existing column.
 443      *
 444      * @param string $table      name of the table
 445      * @param string $columnName name of the column to drop
 446      *
 447      * @return boolean success flag
 448      */
 449
 450     public function dropColumn($table, $columnName)
 451     {
 452         $sql = "ALTER TABLE $table DROP COLUMN $columnName";
 453
 454         $res = $this->conn->query($sql);
 455
 456         if (PEAR::isError($res)) {
 457             throw new Exception($res->getMessage());
 458         }
 459
 460         return true;
 461     }
 462
 463     /**
 464      * Ensures that a table exists with the given
 465      * name and the given column definitions.
 466      *
 467      * If the table does not yet exist, it will
 468      * create the table. If it does exist, it will
 469      * alter the table to match the column definitions.
 470      *
 471      * @param string $tableName name of the table
 472      * @param array  $def       Table definition array
 473      *
 474      * @return boolean success flag
 475      */
 476
 477     public function ensureTable($tableName, $def)
 478     {
 479         $statements = $this->buildEnsureTable($tableName, $def);
 480         return $this->runSqlSet($statements);
 481     }
 482
 483     /**
 484      * Run a given set of SQL commands on the connection in sequence.
 485      * Empty input is ok.
 486      *
 487      * @fixme if multiple statements, wrap in a transaction?
 488      * @param array $statements
 489      * @return boolean success flag
 490      */
 491     function runSqlSet(array $statements)
 492     {
 493         $ok = true;
 494         foreach ($statements as $sql) {
 495             if (defined('DEBUG_INSTALLER')) {
 496                 echo "<tt>" . htmlspecialchars($sql) . "</tt><br/>\n";
 497             }
 498             $res = $this->conn->query($sql);
 499
 500             if (PEAR::isError($res)) {
 501                 throw new Exception($res->getMessage());
 502             }
 503         }
 504         return $ok;
 505     }
 506
 507     /**
 508      * Check a table's status, and if needed build a set
 509      * of SQL statements which change it to be consistent
 510      * with the given table definition.
 511      *
 512      * If the table does not yet exist, statements will
 513      * be returned to create the table. If it does exist,
 514      * statements will be returned to alter the table to
 515      * match the column definitions.
 516      *
 517      * @param string $tableName name of the table
 518      * @param array  $columns   array of ColumnDef
 519      *                          objects for the table
 520      *
 521      * @return array of SQL statements
 522      */
 523
 524     function buildEnsureTable($tableName, array $def)
 525     {
 526         try {
 527             $old = $this->getTableDef($tableName);
 528         } catch (SchemaTableMissingException $e) {
 529             return $this->buildCreateTable($tableName, $def);
 530         }
 531
 532         // Filter the DB-independent table definition to match the current
 533         // database engine's features and limitations.
 534         $def = $this->validateDef($tableName, $def);
 535         $def = $this->filterDef($def);
 536
 537         $statements = array();
 538         $fields = $this->diffArrays($old, $def, 'fields', array($this, 'columnsEqual'));
 539         $uniques = $this->diffArrays($old, $def, 'unique keys');
 540         $indexes = $this->diffArrays($old, $def, 'indexes');
 541         $foreign = $this->diffArrays($old, $def, 'foreign keys');
 542
 543         // Drop any obsolete or modified indexes ahead...
 544         foreach ($indexes['del'] + $indexes['mod'] as $indexName) {
 545             $this->appendDropIndex($statements, $tableName, $indexName);
 546         }
 547
 548         // For efficiency, we want this all in one
 549         // query, instead of using our methods.
 550
 551         $phrase = array();
 552
 553         foreach ($foreign['del'] + $foreign['mod'] as $keyName) {
 554             $this->appendAlterDropForeign($phrase, $keyName);
 555         }
 556
 557         foreach ($uniques['del'] + $uniques['mod'] as $keyName) {
 558             $this->appendAlterDropUnique($phrase, $keyName);
 559         }
 560
 561         foreach ($fields['add'] as $columnName) {
 562             $this->appendAlterAddColumn($phrase, $columnName,
 563                     $def['fields'][$columnName]);
 564         }
 565
 566         foreach ($fields['mod'] as $columnName) {
 567             $this->appendAlterModifyColumn($phrase, $columnName,
 568                     $old['fields'][$columnName],
 569                     $def['fields'][$columnName]);
 570         }
 571
 572         foreach ($fields['del'] as $columnName) {
 573             $this->appendAlterDropColumn($phrase, $columnName);
 574         }
 575
 576         foreach ($uniques['mod'] + $uniques['add'] as $keyName) {
 577             $this->appendAlterAddUnique($phrase, $keyName, $def['unique keys'][$keyName]);
 578         }
 579
 580         foreach ($foreign['mod'] + $foreign['add'] as $keyName) {
 581             $this->appendAlterAddForeign($phrase, $keyName, $def['foreign keys'][$keyName]);
 582         }
 583
 584         $this->appendAlterExtras($phrase, $tableName);
 585
 586         if (count($phrase) > 0) {
 587             $sql = 'ALTER TABLE ' . $tableName . ' ' . implode(",\n", $phrase);
 588             $statements[] = $sql;
 589         }
 590
 591         // Now create any indexes...
 592         foreach ($indexes['mod'] + $indexes['add'] as $indexName) {
 593             $this->appendCreateIndex($statements, $tableName, $indexName, $def['indexes'][$indexName]);
 594         }
 595
 596         return $statements;
 597     }
 598
 599     function diffArrays($oldDef, $newDef, $section, $compareCallback=null)
 600     {
 601         $old = isset($oldDef[$section]) ? $oldDef[$section] : array();
 602         $new = isset($newDef[$section]) ? $newDef[$section] : array();
 603
 604         $oldKeys = array_keys($old);
 605         $newKeys = array_keys($new);
 606
 607         $toadd  = array_diff($newKeys, $oldKeys);
 608         $todrop = array_diff($oldKeys, $newKeys);
 609         $same   = array_intersect($newKeys, $oldKeys);
 610         $tomod  = array();
 611         $tokeep = array();
 612
 613         // Find which fields have actually changed definition
 614         // in a way that we need to tweak them for this DB type.
 615         foreach ($same as $name) {
 616             if ($compareCallback) {
 617                 $same = call_user_func($compareCallback, $old[$name], $new[$name]);
 618             } else {
 619                 $same = ($old[$name] == $new[$name]);
 620             }
 621             if ($same) {
 622                 $tokeep[] = $name;
 623                 continue;
 624             }
 625             $tomod[] = $name;
 626         }
 627         return array('add' => $toadd,
 628                      'del' => $todrop,
 629                      'mod' => $tomod,
 630                      'keep' => $tokeep,
 631                      'count' => count($toadd) + count($todrop) + count($tomod));
 632     }
 633
 634     /**
 635      * Append phrase(s) to an array of partial ALTER TABLE chunks in order
 636      * to add the given column definition to the table.
 637      *
 638      * @param array $phrase
 639      * @param string $columnName
 640      * @param array $cd
 641      */
 642     function appendAlterAddColumn(array &$phrase, $columnName, array $cd)
 643     {
 644         $phrase[] = 'ADD COLUMN ' .
 645                     $this->quoteIdentifier($columnName) .
 646                     ' ' .
 647                     $this->columnSql($cd);
 648     }
 649
 650     /**
 651      * Append phrase(s) to an array of partial ALTER TABLE chunks in order
 652      * to alter the given column from its old state to a new one.
 653      *
 654      * @param array $phrase
 655      * @param string $columnName
 656      * @param array $old previous column definition as found in DB
 657      * @param array $cd current column definition
 658      */
 659     function appendAlterModifyColumn(array &$phrase, $columnName, array $old, array $cd)
 660     {
 661         $phrase[] = 'MODIFY COLUMN ' .
 662                     $this->quoteIdentifier($columnName) .
 663                     ' ' .
 664                     $this->columnSql($cd);
 665     }
 666
 667     /**
 668      * Append phrase(s) to an array of partial ALTER TABLE chunks in order
 669      * to drop the given column definition from the table.
 670      *
 671      * @param array $phrase
 672      * @param string $columnName
 673      */
 674     function appendAlterDropColumn(array &$phrase, $columnName)
 675     {
 676         $phrase[] = 'DROP COLUMN ' . $this->quoteIdentifier($columnName);
 677     }
 678
 679     function appendAlterAddUnique(array &$phrase, $keyName, array $def)
 680     {
 681         $sql = array();
 682         $sql[] = 'ADD';
 683         $this->appendUniqueKeyDef($sql, $keyName, $def);
 684         $phrase[] = implode(' ', $sql);
 685     }
 686
 687     function appendAlterAddForeign(array &$phrase, $keyName, array $def)
 688     {
 689         $sql = array();
 690         $sql[] = 'ADD';
 691         $this->appendForeignKeyDef($sql, $keyName, $def);
 692         $phrase[] = implode(' ', $sql);
 693     }
 694
 695     function appendAlterDropUnique(array &$phrase, $keyName)
 696     {
 697         $phrase[] = 'DROP CONSTRAINT ' . $keyName;
 698     }
 699
 700     function appendAlterDropForeign(array &$phrase, $keyName)
 701     {
 702         $phrase[] = 'DROP FOREIGN KEY ' . $keyName;
 703     }
 704
 705     function appendAlterExtras(array &$phrase, $tableName)
 706     {
 707         // no-op
 708     }
 709
 710     /**
 711      * Quote a db/table/column identifier if necessary.
 712      *
 713      * @param string $name
 714      * @return string
 715      */
 716     function quoteIdentifier($name)
 717     {
 718         return $name;
 719     }
 720
 721     function quoteDefaultValue($cd)
 722     {
 723         if ($cd['type'] == 'datetime' && $cd['default'] == 'CURRENT_TIMESTAMP') {
 724             return $cd['default'];
 725         } else {
 726             return $this->quoteValue($cd['default']);
 727         }
 728     }
 729
 730     function quoteValue($val)
 731     {
 732         return $this->conn->quoteSmart($val);
 733     }
 734
 735     /**
 736      * Check if two column definitions are equivalent.
 737      * The default implementation checks _everything_ but in many cases
 738      * you may be able to discard a bunch of equivalencies.
 739      *
 740      * @param array $a
 741      * @param array $b
 742      * @return boolean
 743      */
 744     function columnsEqual(array $a, array $b)
 745     {
 746         return !array_diff_assoc($a, $b) && !array_diff_assoc($b, $a);
 747     }
 748
 749     /**
 750      * Returns the array of names from an array of
 751      * ColumnDef objects.
 752      *
 753      * @param array $cds array of ColumnDef objects
 754      *
 755      * @return array strings for name values
 756      */
 757
 758     protected function _names($cds)
 759     {
 760         $names = array();
 761
 762         foreach ($cds as $cd) {
 763             $names[] = $cd->name;
 764         }
 765
 766         return $names;
 767     }
 768
 769     /**
 770      * Get a ColumnDef from an array matching
 771      * name.
 772      *
 773      * @param array  $cds  Array of ColumnDef objects
 774      * @param string $name Name of the column
 775      *
 776      * @return ColumnDef matching item or null if no match.
 777      */
 778
 779     protected function _byName($cds, $name)
 780     {
 781         foreach ($cds as $cd) {
 782             if ($cd->name == $name) {
 783                 return $cd;
 784             }
 785         }
 786
 787         return null;
 788     }
 789
 790     /**
 791      * Return the proper SQL for creating or
 792      * altering a column.
 793      *
 794      * Appropriate for use in CREATE TABLE or
 795      * ALTER TABLE statements.
 796      *
 797      * @param ColumnDef $cd column to create
 798      *
 799      * @return string correct SQL for that column
 800      */
 801
 802     function columnSql(array $cd)
 803     {
 804         $line = array();
 805         $line[] = $this->typeAndSize($cd);
 806
 807         if (isset($cd['default'])) {
 808             $line[] = 'default';
 809             $line[] = $this->quoteDefaultValue($cd);
 810         } else if (!empty($cd['not null'])) {
 811             // Can't have both not null AND default!
 812             $line[] = 'not null';
 813         }
 814
 815         return implode(' ', $line);
 816     }
 817
 818     /**
 819      *
 820      * @param string $column canonical type name in defs
 821      * @return string native DB type name
 822      */
 823     function mapType($column)
 824     {
 825         return $column;
 826     }
 827
 828     function typeAndSize($column)
 829     {
 830         //$type = $this->mapType($column);
 831         $type = $column['type'];
 832         if (isset($column['size'])) {
 833             $type = $column['size'] . $type;
 834         }
 835         $lengths = array();
 836
 837         if (isset($column['precision'])) {
 838             $lengths[] = $column['precision'];
 839             if (isset($column['scale'])) {
 840                 $lengths[] = $column['scale'];
 841             }
 842         } else if (isset($column['length'])) {
 843             $lengths[] = $column['length'];
 844         }
 845
 846         if ($lengths) {
 847             return $type . '(' . implode(',', $lengths) . ')';
 848         } else {
 849             return $type;
 850         }
 851     }
 852
 853     /**
 854      * Convert an old-style set of ColumnDef objects into the current
 855      * Drupal-style schema definition array, for backwards compatibility
 856      * with plugins written for 0.9.x.
 857      *
 858      * @param string $tableName
 859      * @param array $defs: array of ColumnDef objects
 860      * @return array
 861      */
 862     protected function oldToNew($tableName, array $defs)
 863     {
 864         $table = array();
 865         $prefixes = array(
 866             'tiny',
 867             'small',
 868             'medium',
 869             'big',
 870         );
 871         foreach ($defs as $cd) {
 872             $column = array();
 873             $column['type'] = $cd->type;
 874             foreach ($prefixes as $prefix) {
 875                 if (substr($cd->type, 0, strlen($prefix)) == $prefix) {
 876                     $column['type'] = substr($cd->type, strlen($prefix));
 877                     $column['size'] = $prefix;
 878                     break;
 879                 }
 880             }
 881
 882             if ($cd->size) {
 883                 if ($cd->type == 'varchar' || $cd->type == 'char') {
 884                     $column['length'] = $cd->size;
 885                 }
 886             }
 887             if (!$cd->nullable) {
 888                 $column['not null'] = true;
 889             }
 890             if ($cd->auto_increment) {
 891                 $column['type'] = 'serial';
 892             }
 893             if ($cd->default) {
 894                 $column['default'] = $cd->default;
 895             }
 896             $table['fields'][$cd->name] = $column;
 897
 898             if ($cd->key == 'PRI') {
 899                 // If multiple columns are defined as primary key,
 900                 // we'll pile them on in sequence.
 901                 if (!isset($table['primary key'])) {
 902                     $table['primary key'] = array();
 903                 }
 904                 $table['primary key'][] = $cd->name;
 905             } else if ($cd->key == 'MUL') {
 906                 // Individual multiple-value indexes are only per-column
 907                 // using the old ColumnDef syntax.
 908                 $idx = "{$tableName}_{$cd->name}_idx";
 909                 $table['indexes'][$idx] = array($cd->name);
 910             } else if ($cd->key == 'UNI') {
 911                 // Individual unique-value indexes are only per-column
 912                 // using the old ColumnDef syntax.
 913                 $idx = "{$tableName}_{$cd->name}_idx";
 914                 $table['unique keys'][$idx] = array($cd->name);
 915             }
 916         }
 917
 918         return $table;
 919     }
 920
 921     /**
 922      * Filter the given table definition array to match features available
 923      * in this database.
 924      *
 925      * This lets us strip out unsupported things like comments, foreign keys,
 926      * or type variants that we wouldn't get back from getTableDef().
 927      *
 928      * @param array $tableDef
 929      */
 930     function filterDef(array $tableDef)
 931     {
 932         return $tableDef;
 933     }
 934
 935     /**
 936      * Validate a table definition array, checking for basic structure.
 937      *
 938      * If necessary, converts from an old-style array of ColumnDef objects.
 939      *
 940      * @param string $tableName
 941      * @param array $def: table definition array
 942      * @return array validated table definition array
 943      *
 944      * @throws Exception on wildly invalid input
 945      */
 946     function validateDef($tableName, array $def)
 947     {
 948         if (isset($def[0]) && $def[0] instanceof ColumnDef) {
 949             $def = $this->oldToNew($tableName, $def);
 950         }
 951
 952         // A few quick checks :D
 953         if (!isset($def['fields'])) {
 954             throw new Exception("Invalid table definition for $tableName: no fields.");
 955         }
 956
 957         return $def;
 958     }
 959
 960     function isNumericType($type)
 961     {
 962         $type = strtolower($type);
 963         $known = array('int', 'serial', 'numeric');
 964         return in_array($type, $known);
 965     }
 966
 967     /**
 968      * Pull info from the query into a fun-fun array of dooooom
 969      *
 970      * @param string $sql
 971      * @return array of arrays
 972      */
 973     protected function fetchQueryData($sql)
 974     {
 975         $res = $this->conn->query($sql);
 976         if (PEAR::isError($res)) {
 977             throw new Exception($res->getMessage());
 978         }
 979
 980         $out = array();
 981         $row = array();
 982         while ($res->fetchInto($row, DB_FETCHMODE_ASSOC)) {
 983             $out[] = $row;
 984         }
 985         $res->free();
 986
 987         return $out;
 988     }
 989
 990 }
 991
 992 class SchemaTableMissingException extends Exception
 993 {
 994     // no-op
 995 }
 996