extlib/DB/DataObject/Generator.php

   1 <?php
   2 /**
   3  * Generation tools for DB_DataObject
   4  *
   5  * PHP versions 4 and 5
   6  *
   7  * LICENSE: This source file is subject to version 3.01 of the PHP license
   8  * that is available through the world-wide-web at the following URI:
   9  * http://www.php.net/license/3_01.txt.  If you did not receive a copy of
  10  * the PHP License and are unable to obtain it through the web, please
  11  * send a note to license@php.net so we can mail you a copy immediately.
  12  *
  13  * @category   Database
  14  * @package    DB_DataObject
  15  * @author     Alan Knowles <alan@akbkhome.com>
  16  * @copyright  1997-2006 The PHP Group
  17  * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
  18  * @version    CVS: $Id: Generator.php 327926 2012-10-08 02:42:09Z alan_k $
  19  * @link       http://pear.php.net/package/DB_DataObject
  20  */
  21
  22  /*
  23  * Security Notes:
  24  *   This class uses eval to create classes on the fly.
  25  *   The table name and database name are used to check the database before writing the
  26  *   class definitions, we now check for quotes and semi-colon's in both variables
  27  *   so I cant see how it would be possible to generate code even if
  28  *   for some crazy reason you took the classname and table name from User Input.
  29  *
  30  *   If you consider that wrong, or can prove it.. let me know!
  31  */
  32
  33  /**
  34  *
  35  * Config _$ptions
  36  * [DB_DataObject]
  37  * ; optional default = DB/DataObject.php
  38  * extends_location =
  39  * ; optional default = DB_DataObject
  40  * extends =
  41  * ; alter the extends field when updating a class (defaults to only replacing DB_DataObject)
  42  * generator_class_rewrite = ANY|specific_name   // default is DB_DataObject
  43  *
  44  */
  45
  46 /**
  47  * Needed classes
  48  * We lazy load here, due to problems with the tests not setting up include path correctly.
  49  * FIXME!
  50  */
  51 class_exists('DB_DataObject') ? '' : require_once 'DB/DataObject.php';
  52 //require_once('Config.php');
  53
  54 /**
  55  * Generator class
  56  *
  57  * @package DB_DataObject
  58  */
  59 class DB_DataObject_Generator extends DB_DataObject
  60 {
  61     /* =========================================================== */
  62     /*  Utility functions - for building db config files           */
  63     /* =========================================================== */
  64
  65     /**
  66      * Array of table names
  67      *
  68      * @var array
  69      * @access private
  70      */
  71     var $tables;
  72
  73     /**
  74      * associative array table -> array of table row objects
  75      *
  76      * @var array
  77      * @access private
  78      */
  79     var $_definitions;
  80
  81     /**
  82      * active table being output
  83      *
  84      * @var string
  85      * @access private
  86      */
  87     var $table; // active tablename
  88
  89     /**
  90      * links (generated)
  91      *
  92      * @var array
  93      * @access private
  94      */
  95     var $_fkeys; // active tablename
  96
  97     /**
  98      * The 'starter' = call this to start the process
  99      *
 100      * @access  public
 101      * @return  none
 102      */
 103     function start()
 104     {
 105         $options = &PEAR::getStaticProperty('DB_DataObject','options');
 106         $db_driver = empty($options['db_driver']) ? 'DB' : $options['db_driver'];
 107
 108         $databases = array();
 109         foreach($options as $k=>$v) {
 110             if (substr($k,0,9) == 'database_') {
 111                 $databases[substr($k,9)] = $v;
 112             }
 113         }
 114
 115         if (isset($options['database'])) {
 116             if ($db_driver == 'DB') {
 117                 require_once 'DB.php';
 118                 $dsn = DB::parseDSN($options['database']);
 119             } else {
 120                 require_once 'MDB2.php';
 121                 $dsn = MDB2::parseDSN($options['database']);
 122             }
 123
 124             if (!isset($database[$dsn['database']])) {
 125                 $databases[$dsn['database']] = $options['database'];
 126             }
 127         }
 128
 129         foreach($databases as $databasename => $database) {
 130             if (!$database) {
 131                 continue;
 132             }
 133             $this->debug("CREATING FOR $databasename\n");
 134             $class = get_class($this);
 135             $t = new $class;
 136             $t->_database_dsn = $database;
 137
 138
 139             $t->_database = $databasename;
 140             if ($db_driver == 'DB') {
 141                 require_once 'DB.php';
 142                 $dsn = DB::parseDSN($database);
 143             } else {
 144                 require_once 'MDB2.php';
 145                 $dsn = MDB2::parseDSN($database);
 146             }
 147
 148             if (($dsn['phptype'] == 'sqlite') && is_file($databasename)) {
 149                 $t->_database = basename($t->_database);
 150             }
 151             $t->_createTableList();
 152             $t->_createForiegnKeys();
 153
 154             foreach(get_class_methods($class) as $method) {
 155                 if (substr($method,0,8 ) != 'generate') {
 156                     continue;
 157                 }
 158                 $this->debug("calling $method");
 159                 $t->$method();
 160             }
 161         }
 162         $this->debug("DONE\n\n");
 163     }
 164
 165     /**
 166      * Output File was config object, now just string
 167      * Used to generate the Tables
 168      *
 169      * @var    string outputbuffer for table definitions
 170      * @access private
 171      */
 172     var $_newConfig;
 173
 174     /**
 175      * Build a list of tables;
 176      * and store it in $this->tables and $this->_definitions[tablename];
 177      *
 178      * @access  private
 179      * @return  none
 180      */
 181     function _createTableList()
 182     {
 183         $this->_connect();
 184
 185         $options = &PEAR::getStaticProperty('DB_DataObject','options');
 186
 187
 188
 189         $__DB= &$GLOBALS['_DB_DATAOBJECT']['CONNECTIONS'][$this->_database_dsn_md5];
 190
 191         $db_driver = empty($options['db_driver']) ? 'DB' : $options['db_driver'];
 192         $is_MDB2 = ($db_driver != 'DB') ? true : false;
 193
 194         if (is_object($__DB) && is_a($__DB , 'PEAR_Error')) {
 195             return PEAR::raiseError($__DB->toString(), null, PEAR_ERROR_DIE);
 196         }
 197
 198         if (!$is_MDB2) {
 199             // try getting a list of schema tables first. (postgres)
 200             $__DB->expectError(DB_ERROR_UNSUPPORTED);
 201             $this->tables = $__DB->getListOf('schema.tables');
 202             $__DB->popExpect();
 203         } else {
 204             /**
 205              * set portability and some modules to fetch the informations
 206              */
 207             $db_options = PEAR::getStaticProperty('MDB2','options');
 208             if (empty($db_options)) {
 209                 $__DB->setOption('portability', MDB2_PORTABILITY_ALL ^ MDB2_PORTABILITY_FIX_CASE);
 210             }
 211
 212             $__DB->loadModule('Manager');
 213             $__DB->loadModule('Reverse');
 214         }
 215
 216         if ((empty($this->tables) || (is_object($this->tables) && is_a($this->tables , 'PEAR_Error')))) {
 217             //if that fails fall back to clasic tables list.
 218             if (!$is_MDB2) {
 219                 // try getting a list of schema tables first. (postgres)
 220                 $__DB->expectError(DB_ERROR_UNSUPPORTED);
 221                 $this->tables = $__DB->getListOf('tables');
 222                 $__DB->popExpect();
 223             } else  {
 224                 $this->tables = $__DB->manager->listTables();
 225                 $sequences = $__DB->manager->listSequences();
 226                 foreach ($sequences as $k => $v) {
 227                     $this->tables[] = $__DB->getSequenceName($v);
 228                 }
 229             }
 230         }
 231
 232         if (is_object($this->tables) && is_a($this->tables , 'PEAR_Error')) {
 233             return PEAR::raiseError($this->tables->toString(), null, PEAR_ERROR_DIE);
 234         }
 235
 236         // build views as well if asked to.
 237         if (!empty($options['build_views'])) {
 238             if (!$is_MDB2) {
 239                 $views = $__DB->getListOf(is_string($options['build_views']) ?
 240                                     $options['build_views'] : 'views');
 241             } else {
 242                 $views = $__DB->manager->listViews();
 243             }
 244             if (is_object($views) && is_a($views,'PEAR_Error')) {
 245                 return PEAR::raiseError(
 246                 'Error getting Views (check the PEAR bug database for the fix to DB), ' .
 247                 $views->toString(),
 248                 null,
 249                 PEAR_ERROR_DIE
 250                 );
 251             }
 252             $this->tables = array_merge ($this->tables, $views);
 253         }
 254
 255         // declare a temporary table to be filled with matching tables names
 256         $tmp_table = array();
 257
 258
 259         foreach($this->tables as $table) {
 260             if (isset($options['generator_include_regex']) &&
 261                     !preg_match($options['generator_include_regex'],$table)) {
 262                 $this->debug("SKIPPING (generator_include_regex) : $table");
 263                 continue;
 264             }
 265
 266             if (isset($options['generator_exclude_regex']) &&
 267                     preg_match($options['generator_exclude_regex'],$table)) {
 268                 continue;
 269             }
 270
 271             $strip = empty($options['generator_strip_schema']) ? false : $options['generator_strip_schema'];
 272             $strip = is_numeric($strip) ? (bool) $strip : $strip;
 273             $strip = (is_string($strip) && strtolower($strip) == 'true') ? true : $strip;
 274
 275             // postgres strip the schema bit from the
 276             if (!empty($strip) ) {
 277
 278                 if (!is_string($strip) || preg_match($strip, $table)) {
 279                     $bits = explode('.', $table,2);
 280                     $table = $bits[0];
 281                     if (count($bits) > 1) {
 282                         $table = $bits[1];
 283                     }
 284                 }
 285             }
 286             $this->debug("EXTRACTING : $table");
 287
 288             $quotedTable = !empty($options['quote_identifiers_tableinfo']) ?
 289                 $__DB->quoteIdentifier($table) : $table;
 290
 291             if (!$is_MDB2) {
 292
 293                 $defs =  $__DB->tableInfo($quotedTable);
 294             } else {
 295                 $defs =  $__DB->reverse->tableInfo($quotedTable);
 296                 // rename the length value, so it matches db's return.
 297
 298             }
 299
 300             if (is_object($defs) && is_a($defs,'PEAR_Error')) {
 301                 // running in debug mode should pick this up as a big warning..
 302                 $this->debug("Error reading tableInfo: $table");
 303                 $this->raiseError('Error reading tableInfo, '. $defs->toString());
 304                 continue;
 305             }
 306             // cast all definitions to objects - as we deal with that better.
 307
 308
 309
 310             foreach($defs as $def) {
 311                 if (!is_array($def)) {
 312                     continue;
 313                 }
 314                 // rename the length value, so it matches db's return.
 315                 if (isset($def['length']) && !isset($def['len'])) {
 316                     $def['len'] = $def['length'];
 317                 }
 318                 $this->_definitions[$table][] = (object) $def;
 319
 320             }
 321             // we find a matching table, just  store it into a temporary array
 322             $tmp_table[] = $table;
 323
 324
 325         }
 326         // the temporary table array is now the right one (tables names matching
 327         // with regex expressions have been removed)
 328         $this->tables = $tmp_table;
 329
 330         //print_r($this->_definitions);
 331     }
 332
 333     /**
 334      * Auto generation of table data.
 335      *
 336      * it will output to db_oo_{database} the table definitions
 337      *
 338      * @access  private
 339      * @return  none
 340      */
 341     function generateDefinitions()
 342     {
 343         $this->debug("Generating Definitions file:        ");
 344         if (!$this->tables) {
 345             $this->debug("-- NO TABLES -- \n");
 346             return;
 347         }
 348
 349         $options = &PEAR::getStaticProperty('DB_DataObject','options');
 350
 351
 352         //$this->_newConfig = new Config('IniFile');
 353         $this->_newConfig = '';
 354         foreach($this->tables as $this->table) {
 355             $this->_generateDefinitionsTable();
 356         }
 357         $this->_connect();
 358         // dont generate a schema if location is not set
 359         // it's created on the fly!
 360         if (empty($options['schema_location']) && empty($options["ini_{$this->_database}"]) ) {
 361             return;
 362         }
 363         if (!empty($options['generator_no_ini'])) { // built in ini files..
 364             return;
 365         }
 366         $base =  @$options['schema_location'];
 367         if (isset($options["ini_{$this->_database}"])) {
 368             $file = $options["ini_{$this->_database}"];
 369         } else {
 370             $file = "{$base}/{$this->_database}.ini";
 371         }
 372
 373         if (!file_exists(dirname($file))) {
 374             require_once 'System.php';
 375             System::mkdir(array('-p','-m',0755,dirname($file)));
 376         }
 377         $this->debug("Writing ini as {$file}\n");
 378         //touch($file);
 379         $tmpname = tempnam(session_save_path(),'DataObject_');
 380         //print_r($this->_newConfig);
 381         $fh = fopen($tmpname,'w');
 382         if (!$fh) {
 383             return PEAR::raiseError(
 384                 "Failed to create temporary file: $tmpname\n".
 385                 "make sure session.save_path is set and is writable\n"
 386                 ,null, PEAR_ERROR_DIE);
 387         }
 388         fwrite($fh,$this->_newConfig);
 389         fclose($fh);
 390         $perms = file_exists($file) ? fileperms($file) : 0755;
 391         // windows can fail doing this. - not a perfect solution but otherwise it's getting really kludgy..
 392
 393         if (!@rename($tmpname, $file)) {
 394             unlink($file);
 395             rename($tmpname, $file);
 396         }
 397         chmod($file,$perms);
 398         //$ret = $this->_newConfig->writeInput($file,false);
 399
 400         //if (PEAR::isError($ret) ) {
 401         //    return PEAR::raiseError($ret->message,null,PEAR_ERROR_DIE);
 402         // }
 403     }
 404      /**
 405      * create the data for Foreign Keys (for links.ini)
 406      * Currenly only works with mysql / mysqli / posgtreas
 407      * to use, you must set option: generate_links=true
 408      *
 409      * @author Pascal Schöni
 410      */
 411
 412     function _createForiegnKeys()
 413     {
 414         $options = PEAR::getStaticProperty('DB_DataObject','options');
 415         if (empty($options['generate_links'])) {
 416             return false;
 417         }
 418         $__DB = &$GLOBALS['_DB_DATAOBJECT']['CONNECTIONS'][$this->_database_dsn_md5];
 419         if (!in_array($__DB->phptype, array('mysql', 'mysqli', 'pgsql'))) {
 420             echo "WARNING: cant handle non-mysql and pgsql introspection for defaults.";
 421             return; // cant handle non-mysql introspection for defaults.
 422         }
 423         $this->debug("generateForeignKeys: Start");
 424         $DB = $this->getDatabaseConnection();
 425
 426         $fk = array();
 427
 428
 429         switch ($DB->phptype) {
 430
 431
 432             case 'pgsql':
 433                 foreach($this->tables as $this->table) {
 434                     $quotedTable = !empty($options['quote_identifiers_tableinfo']) ?  $DB->quoteIdentifier($table)  : $this->table;
 435                     $res =& $DB->query("SELECT
 436                                 pg_catalog.pg_get_constraintdef(r.oid, true) AS condef
 437                             FROM pg_catalog.pg_constraint r,
 438                                  pg_catalog.pg_class c
 439                             WHERE c.oid=r.conrelid
 440                                   AND r.contype = 'f'
 441                                   AND c.relname = '" . $quotedTable . "'");
 442                     if (PEAR::isError($res)) {
 443                         die($res->getMessage());
 444                     }
 445
 446                     while ($row = $res->fetchRow(DB_FETCHMODE_ASSOC)) {
 447                         $treffer = array();
 448                         // this only picks up one of these.. see this for why: http://pear.php.net/bugs/bug.php?id=17049
 449                         preg_match(
 450                             "/FOREIGN KEY \((\w*)\) REFERENCES (\w*)\((\w*)\)/i",
 451                             $row['condef'],
 452                             $treffer);
 453                         if (!count($treffer)) {
 454                             continue;
 455                         }
 456                         $fk[$this->table][$treffer[1]] = $treffer[2] . ":" . $treffer[3];
 457                     }
 458                 }
 459                 break;
 460
 461
 462             case 'mysql':
 463             case 'mysqli':
 464             default:
 465
 466                 foreach($this->tables as $this->table) {
 467                     $quotedTable = !empty($options['quote_identifiers_tableinfo']) ?  $DB->quoteIdentifier($table)  : $this->table;
 468
 469                     $res =& $DB->query('SHOW CREATE TABLE ' . $quotedTable );
 470
 471                     if (PEAR::isError($res)) {
 472                         die($res->getMessage());
 473                     }
 474
 475                     $text = $res->fetchRow(DB_FETCHMODE_DEFAULT, 0);
 476                     $treffer = array();
 477                     // Extract FOREIGN KEYS
 478                     preg_match_all(
 479                         "/FOREIGN KEY \(`(\w*)`\) REFERENCES `(\w*)` \(`(\w*)`\)/i",
 480                         $text[1],
 481                         $treffer,
 482                         PREG_SET_ORDER);
 483
 484                     if (!count($treffer)) {
 485                         continue;
 486                     }
 487                     foreach($treffer as $i=> $tref) {
 488                         $fk[$this->table][$tref[1]] = $tref[2] . ":" . $tref[3];
 489                     }
 490
 491                 }
 492
 493         }
 494
 495
 496         $this->_fkeys = $fk;
 497
 498
 499
 500
 501
 502     }
 503
 504
 505     /**
 506      * generate Foreign Keys (for links.ini)
 507      * Currenly only works with mysql / mysqli
 508      * to use, you must set option: generate_links=true
 509      *
 510      * @author Pascal Schöni
 511      */
 512     function generateForeignKeys()
 513     {
 514         $options = PEAR::getStaticProperty('DB_DataObject','options');
 515         if (empty($options['generate_links'])) {
 516             return false;
 517         }
 518         $__DB = &$GLOBALS['_DB_DATAOBJECT']['CONNECTIONS'][$this->_database_dsn_md5];
 519         if (!in_array($__DB->phptype, array('mysql', 'mysqli', 'pgsql'))) {
 520             echo "WARNING: cant handle non-mysql and pgsql introspection for defaults.";
 521             return; // cant handle non-mysql introspection for defaults.
 522         }
 523         $this->debug("generateForeignKeys: Start");
 524
 525         $fk = $this->_fkeys;
 526         $links_ini = "";
 527
 528         foreach($fk as $table => $details) {
 529             $links_ini .= "[$table]\n";
 530             foreach ($details as $col => $ref) {
 531                 $links_ini .= "$col = $ref\n";
 532             }
 533             $links_ini .= "\n";
 534         }
 535
 536         // dont generate a schema if location is not set
 537         // it's created on the fly!
 538         $options = PEAR::getStaticProperty('DB_DataObject','options');
 539
 540         if (!empty($options['schema_location'])) {
 541              $file = "{$options['schema_location']}/{$this->_database}.links.ini";
 542         } elseif (isset($options["ini_{$this->_database}"])) {
 543             $file = preg_replace('/\.ini/','.links.ini',$options["ini_{$this->_database}"]);
 544         } else {
 545             $this->debug("generateForeignKeys: SKIP - schema_location or ini_{database} was not set");
 546             return;
 547         }
 548
 549
 550         if (!file_exists(dirname($file))) {
 551             mkdir(dirname($file),0755, true);
 552         }
 553
 554         $this->debug("Writing ini as {$file}\n");
 555
 556         //touch($file); // not sure why this is needed?
 557         $tmpname = tempnam(session_save_path(),'DataObject_');
 558
 559         $fh = fopen($tmpname,'w');
 560         if (!$fh) {
 561             return PEAR::raiseError(
 562                 "Failed to create temporary file: $tmpname\n".
 563                 "make sure session.save_path is set and is writable\n"
 564                 ,null, PEAR_ERROR_DIE);
 565         }
 566         fwrite($fh,$links_ini);
 567         fclose($fh);
 568         $perms = file_exists($file) ? fileperms($file) : 0755;
 569         // windows can fail doing this. - not a perfect solution but otherwise it's getting really kludgy..
 570         if (!@rename($tmpname, $file)) {
 571             unlink($file);
 572             rename($tmpname, $file);
 573         }
 574         chmod($file, $perms);
 575     }
 576
 577
 578     /**
 579      * The table geneation part
 580      *
 581      * @access  private
 582      * @return  tabledef and keys array.
 583      */
 584     function _generateDefinitionsTable()
 585     {
 586         global $_DB_DATAOBJECT;
 587         $options = PEAR::getStaticProperty('DB_DataObject','options');
 588         $defs = $this->_definitions[$this->table];
 589         $this->_newConfig .= "\n[{$this->table}]\n";
 590         $keys_out =  "\n[{$this->table}__keys]\n";
 591         $keys_out_primary = '';
 592         $keys_out_secondary = '';
 593         if (@$_DB_DATAOBJECT['CONFIG']['debug'] > 2) {
 594             echo "TABLE STRUCTURE FOR {$this->table}\n";
 595             print_r($defs);
 596         }
 597         $DB = $this->getDatabaseConnection();
 598         $dbtype = $DB->phptype;
 599
 600         $ret = array(
 601                 'table' => array(),
 602                 'keys' => array(),
 603             );
 604
 605         $ret_keys_primary = array();
 606         $ret_keys_secondary = array();
 607
 608
 609
 610         foreach($defs as $t) {
 611
 612             $n=0;
 613             $write_ini = true;
 614
 615
 616             switch (strtoupper($t->type)) {
 617
 618                 case 'INT':
 619                 case 'INT2':    // postgres
 620                 case 'INT4':    // postgres
 621                 case 'INT8':    // postgres
 622                 case 'SERIAL4': // postgres
 623                 case 'SERIAL8': // postgres
 624                 case 'INTEGER':
 625                 case 'TINYINT':
 626                 case 'SMALLINT':
 627                 case 'MEDIUMINT':
 628                 case 'BIGINT':
 629                     $type = DB_DATAOBJECT_INT;
 630                     if ($t->len == 1) {
 631                         $type +=  DB_DATAOBJECT_BOOL;
 632                     }
 633                     break;
 634
 635                 case 'REAL':
 636                 case 'DOUBLE':
 637                 case 'DOUBLE PRECISION': // double precision (firebird)
 638                 case 'FLOAT':
 639                 case 'FLOAT4': // real (postgres)
 640                 case 'FLOAT8': // double precision (postgres)
 641                 case 'DECIMAL':
 642                 case 'MONEY':  // mssql and maybe others
 643                 case 'NUMERIC':
 644                 case 'NUMBER': // oci8
 645                     $type = DB_DATAOBJECT_INT; // should really by FLOAT!!! / MONEY...
 646                     break;
 647
 648                 case 'YEAR':
 649                     $type = DB_DATAOBJECT_INT;
 650                     break;
 651
 652                 case 'BIT':
 653                 case 'BOOL':
 654                 case 'BOOLEAN':
 655
 656                     $type = DB_DATAOBJECT_BOOL;
 657                     // postgres needs to quote '0'
 658                     if ($dbtype == 'pgsql') {
 659                         $type +=  DB_DATAOBJECT_STR;
 660                     }
 661                     break;
 662
 663                 case 'STRING':
 664                 case 'CHAR':
 665                 case 'VARCHAR':
 666                 case 'VARCHAR2':
 667                 case 'TINYTEXT':
 668
 669                 case 'ENUM':
 670                 case 'SET':         // not really but oh well
 671
 672                 case 'POINT':       // mysql geometry stuff - not really string - but will do..
 673
 674                 case 'TIMESTAMPTZ': // postgres
 675                 case 'BPCHAR':      // postgres
 676                 case 'INTERVAL':    // postgres (eg. '12 days')
 677
 678                 case 'CIDR':        // postgres IP net spec
 679                 case 'INET':        // postgres IP
 680                 case 'MACADDR':     // postgress network Mac address.
 681
 682                 case 'INTEGER[]':   // postgres type
 683                 case 'BOOLEAN[]':   // postgres type
 684
 685                     $type = DB_DATAOBJECT_STR;
 686                     break;
 687
 688                 case 'TEXT':
 689                 case 'MEDIUMTEXT':
 690                 case 'LONGTEXT':
 691                 case '_TEXT':   //postgres (?? view ??)
 692
 693                     $type = DB_DATAOBJECT_STR + DB_DATAOBJECT_TXT;
 694                     break;
 695
 696
 697                 case 'DATE':
 698                     $type = DB_DATAOBJECT_STR + DB_DATAOBJECT_DATE;
 699                     break;
 700
 701                 case 'TIME':
 702                     $type = DB_DATAOBJECT_STR + DB_DATAOBJECT_TIME;
 703                     break;
 704
 705
 706                 case 'DATETIME':
 707
 708                     $type = DB_DATAOBJECT_STR + DB_DATAOBJECT_DATE + DB_DATAOBJECT_TIME;
 709                     break;
 710
 711                 case 'TIMESTAMP': // do other databases use this???
 712
 713                     $type = ($dbtype == 'mysql') ?
 714                         DB_DATAOBJECT_MYSQLTIMESTAMP :
 715                         DB_DATAOBJECT_STR + DB_DATAOBJECT_DATE + DB_DATAOBJECT_TIME;
 716                     break;
 717
 718
 719                 case 'BLOB':       /// these should really be ignored!!!???
 720                 case 'TINYBLOB':
 721                 case 'MEDIUMBLOB':
 722                 case 'LONGBLOB':
 723
 724                 case 'CLOB': // oracle character lob support
 725
 726                 case 'BYTEA':   // postgres blob support..
 727                     $type = DB_DATAOBJECT_STR + DB_DATAOBJECT_BLOB;
 728                     break;
 729
 730                 default:
 731                     echo "*****************************************************************\n".
 732                          "**               WARNING UNKNOWN TYPE                          **\n".
 733                          "** Found column '{$t->name}', of type  '{$t->type}'            **\n".
 734                          "** Please submit a bug, describe what type you expect this     **\n".
 735                          "** column  to be                                               **\n".
 736                          "** ---------POSSIBLE FIX / WORKAROUND -------------------------**\n".
 737                          "** Try using MDB2 as the backend - eg set the config option    **\n".
 738                          "** db_driver = MDB2                                            **\n".
 739                          "*****************************************************************\n";
 740                     $write_ini = false;
 741                     break;
 742             }
 743
 744             if (!preg_match('/^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*$/', $t->name)) {
 745                 echo "*****************************************************************\n".
 746                      "**               WARNING COLUMN NAME UNUSABLE                  **\n".
 747                      "** Found column '{$t->name}', of type  '{$t->type}'            **\n".
 748                      "** Since this column name can't be converted to a php variable **\n".
 749                      "** name, and the whole idea of mapping would result in a mess  **\n".
 750                      "** This column has been ignored...                             **\n".
 751                      "*****************************************************************\n";
 752                 continue;
 753             }
 754
 755             if (!strlen(trim($t->name))) {
 756                 continue; // is this a bug?
 757             }
 758
 759             if (preg_match('/not[ _]null/i',$t->flags)) {
 760                 $type += DB_DATAOBJECT_NOTNULL;
 761             }
 762
 763
 764             if (in_array($t->name,array('null','yes','no','true','false'))) {
 765                 echo "*****************************************************************\n".
 766                      "**                             WARNING                         **\n".
 767                      "** Found column '{$t->name}', which is invalid in an .ini file **\n".
 768                      "** This line will not be writen to the file - you will have    **\n".
 769                      "** define the keys()/method manually.                          **\n".
 770                      "*****************************************************************\n";
 771                 $write_ini = false;
 772             } else {
 773                 $this->_newConfig .= "{$t->name} = $type\n";
 774             }
 775
 776             $ret['table'][$t->name] = $type;
 777             // i've no idea if this will work well on other databases?
 778             // only use primary key or nextval(), cause the setFrom blocks you setting all key items...
 779             // if no keys exist fall back to using unique
 780             //echo "\n{$t->name} => {$t->flags}\n";
 781             $secondary_key_match = isset($options['generator_secondary_key_match']) ? $options['generator_secondary_key_match'] : 'primary|unique';
 782
 783             $m = array();
 784             if (preg_match('/(auto_increment|nextval\(([^)]*))/i',rawurldecode($t->flags),$m)
 785                 || (isset($t->autoincrement) && ($t->autoincrement === true))) {
 786
 787                 $sn = 'N';
 788                 if ($DB->phptype == 'pgsql' && !empty($m[2])) {
 789                     $sn = preg_replace('/[("]+/','', $m[2]);
 790                     //echo urldecode($t->flags) . "\n" ;
 791                 }
 792                 // native sequences = 2
 793                 if ($write_ini) {
 794                     $keys_out_primary .= "{$t->name} = $sn\n";
 795                 }
 796                 $ret_keys_primary[$t->name] = $sn;
 797
 798             } else if ($secondary_key_match && preg_match('/('.$secondary_key_match.')/i',$t->flags)) {
 799                 // keys.. = 1
 800                 $key_type = 'K';
 801                 if (!preg_match("/(primary)/i",$t->flags)) {
 802                     $key_type = 'U';
 803                 }
 804
 805                 if ($write_ini) {
 806                     $keys_out_secondary .= "{$t->name} = {$key_type}\n";
 807                 }
 808                 $ret_keys_secondary[$t->name] = $key_type;
 809             }
 810
 811
 812         }
 813
 814         $this->_newConfig .= $keys_out . (empty($keys_out_primary) ? $keys_out_secondary : $keys_out_primary);
 815         $ret['keys'] = empty($keys_out_primary) ? $ret_keys_secondary : $ret_keys_primary;
 816
 817         if (@$_DB_DATAOBJECT['CONFIG']['debug'] > 2) {
 818             print_r(array("dump for {$this->table}", $ret));
 819         }
 820
 821         return $ret;
 822
 823
 824     }
 825
 826     /**
 827     * Convert a table name into a class name -> override this if you want a different mapping
 828     *
 829     * @access  public
 830     * @return  string class name;
 831     */
 832
 833
 834     function getClassNameFromTableName($table)
 835     {
 836         $options = &PEAR::getStaticProperty('DB_DataObject','options');
 837         $class_prefix  = empty($options['class_prefix']) ? '' : $options['class_prefix'];
 838         return  $class_prefix.preg_replace('/[^A-Z0-9]/i','_',ucfirst(trim($this->table)));
 839     }
 840
 841
 842     /**
 843     * Convert a table name into a file name -> override this if you want a different mapping
 844     *
 845     * @access  public
 846     * @return  string file name;
 847     */
 848
 849
 850     function getFileNameFromTableName($table)
 851     {
 852         $options = &PEAR::getStaticProperty('DB_DataObject','options');
 853         $base = $options['class_location'];
 854         if (strpos($base,'%s') !== false) {
 855             $base = dirname($base);
 856         }
 857         if (!file_exists($base)) {
 858             require_once 'System.php';
 859             System::mkdir(array('-p',$base));
 860         }
 861         if (strpos($options['class_location'],'%s') !== false) {
 862             $outfilename   = sprintf($options['class_location'],
 863                     preg_replace('/[^A-Z0-9]/i','_',ucfirst($this->table)));
 864         } else {
 865             $outfilename = "{$base}/".preg_replace('/[^A-Z0-9]/i','_',ucfirst($this->table)).".php";
 866         }
 867         return $outfilename;
 868
 869     }
 870
 871
 872      /**
 873     * Convert a column name into a method name (usually prefixed by get/set/validateXXXXX)
 874     *
 875     * @access  public
 876     * @return  string method name;
 877     */
 878
 879
 880     function getMethodNameFromColumnName($col)
 881     {
 882         return ucfirst($col);
 883     }
 884
 885
 886
 887
 888     /*
 889      * building the class files
 890      * for each of the tables output a file!
 891      */
 892     function generateClasses()
 893     {
 894         //echo "Generating Class files:        \n";
 895         $options = &PEAR::getStaticProperty('DB_DataObject','options');
 896
 897         $this->_extends = empty($options['extends']) ? $this->_extends : $options['extends'];
 898         $this->_extendsFile = empty($options['extends_location']) ? $this->_extendsFile : $options['extends_location'];
 899
 900
 901         foreach($this->tables as $this->table) {
 902             $this->table        = trim($this->table);
 903             $this->classname    = $this->getClassNameFromTableName($this->table);
 904             $i = '';
 905             $outfilename        = $this->getFileNameFromTableName($this->table);
 906
 907             $oldcontents = '';
 908             if (file_exists($outfilename)) {
 909                 // file_get_contents???
 910                 $oldcontents = implode('',file($outfilename));
 911             }
 912
 913             $out = $this->_generateClassTable($oldcontents);
 914             $this->debug( "writing $this->classname\n");
 915             $tmpname = tempnam(session_save_path(),'DataObject_');
 916
 917             $fh = fopen($tmpname, "w");
 918             if (!$fh) {
 919                 return PEAR::raiseError(
 920                     "Failed to create temporary file: $tmpname\n".
 921                     "make sure session.save_path is set and is writable\n"
 922                     ,null, PEAR_ERROR_DIE);
 923             }
 924             fputs($fh,$out);
 925             fclose($fh);
 926             $perms = file_exists($outfilename) ? fileperms($outfilename) : 0755;
 927
 928             // windows can fail doing this. - not a perfect solution but otherwise it's getting really kludgy..
 929             if (!@rename($tmpname, $outfilename)) {
 930                 unlink($outfilename);
 931                 rename($tmpname, $outfilename);
 932             }
 933
 934             chmod($outfilename, $perms);
 935         }
 936         //echo $out;
 937     }
 938
 939     /**
 940      * class being extended (can be overridden by [DB_DataObject] extends=xxxx
 941      *
 942      * @var    string
 943      * @access private
 944      */
 945     var $_extends = 'DB_DataObject';
 946
 947     /**
 948      * line to use for require('DB/DataObject.php');
 949      *
 950      * @var    string
 951      * @access private
 952      */
 953     var $_extendsFile = "DB/DataObject.php";
 954
 955     /**
 956      * class being generated
 957      *
 958      * @var    string
 959      * @access private
 960      */
 961     var $_className;
 962
 963     /**
 964      * The table class geneation part - single file.
 965      *
 966      * @access  private
 967      * @return  none
 968      */
 969     function _generateClassTable($input = '')
 970     {
 971         // title = expand me!
 972         $foot = "";
 973         $head = "<?php\n/**\n * Table Definition for {$this->table}\n";
 974         $head .= $this->derivedHookPageLevelDocBlock();
 975         $head .= " */\n";
 976         $head .= $this->derivedHookExtendsDocBlock();
 977
 978
 979         // requires
 980         $head .= "require_once '{$this->_extendsFile}';\n\n";
 981         // add dummy class header in...
 982         // class
 983         $head .= $this->derivedHookClassDocBlock();
 984         $head .= "class {$this->classname} extends {$this->_extends} \n{";
 985
 986         $body =  "\n    ###START_AUTOCODE\n";
 987         $body .= "    /* the code below is auto generated do not remove the above tag */\n\n";
 988         // table
 989
 990         $p = str_repeat(' ',max(2, (18 - strlen($this->table)))) ;
 991
 992         $options = &PEAR::getStaticProperty('DB_DataObject','options');
 993
 994
 995         $var = (substr(phpversion(),0,1) > 4) ? 'public' : 'var';
 996         $var = !empty($options['generator_var_keyword']) ? $options['generator_var_keyword'] : $var;
 997
 998
 999         $body .= "    {$var} \$__table = '{$this->table}';  {$p}// table name\n";
1000
1001         // if we are using the option database_{databasename} = dsn
1002         // then we should add var $_database = here
1003         // as database names may not always match..
1004
1005         if (empty($GLOBALS['_DB_DATAOBJECT']['CONFIG'])) {
1006             DB_DataObject::_loadConfig();
1007         }
1008
1009          // Only include the $_database property if the omit_database_var is unset or false
1010
1011         if (isset($options["database_{$this->_database}"]) && empty($GLOBALS['_DB_DATAOBJECT']['CONFIG']['generator_omit_database_var'])) {
1012             $p = str_repeat(' ',   max(2, (16 - strlen($this->_database))));
1013             $body .= "    {$var} \$_database = '{$this->_database}';  {$p}// database name (used with database_{*} config)\n";
1014         }
1015
1016
1017         if (!empty($options['generator_novars'])) {
1018             $var = '//'.$var;
1019         }
1020
1021         $defs = $this->_definitions[$this->table];
1022
1023         // show nice information!
1024         $connections = array();
1025         $sets = array();
1026
1027         foreach($defs as $t) {
1028             if (!strlen(trim($t->name))) {
1029                 continue;
1030             }
1031             if (!preg_match('/^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*$/', $t->name)) {
1032                 echo "*****************************************************************\n".
1033                      "**               WARNING COLUMN NAME UNUSABLE                  **\n".
1034                      "** Found column '{$t->name}', of type  '{$t->type}'            **\n".
1035                      "** Since this column name can't be converted to a php variable **\n".
1036                      "** name, and the whole idea of mapping would result in a mess  **\n".
1037                      "** This column has been ignored...                             **\n".
1038                      "*****************************************************************\n";
1039                 continue;
1040             }
1041
1042             $p = str_repeat(' ',max(2,  (30 - strlen($t->name))));
1043
1044             $length = empty($t->len) ? '' : '('.$t->len.')';
1045             $body .="    {$var} \${$t->name};  {$p}// {$t->type}$length  {$t->flags}\n";
1046
1047             // can not do set as PEAR::DB table info doesnt support it.
1048             //if (substr($t->Type,0,3) == "set")
1049             //    $sets[$t->Field] = "array".substr($t->Type,3);
1050             $body .= $this->derivedHookVar($t,strlen($p));
1051         }
1052
1053         $body .= $this->derivedHookPostVar($defs);
1054
1055         // THIS IS TOTALLY BORKED old FC creation
1056         // IT WILL BE REMOVED!!!!! in DataObjects 1.6
1057         // grep -r __clone * to find all it's uses
1058         // and replace them with $x = clone($y);
1059         // due to the change in the PHP5 clone design.
1060         $static = 'static';
1061         if ( substr(phpversion(),0,1) < 5) {
1062             $body .= "\n";
1063             $body .= "    /* ZE2 compatibility trick*/\n";
1064             $body .= "    function __clone() { return \$this;}\n";
1065         }
1066
1067
1068         // depricated - in here for BC...
1069         if (!empty($options['static_get'])) {
1070
1071             // simple creation tools ! (static stuff!)
1072             $body .= "\n";
1073             $body .= "    /* Static get */\n";
1074             $body .= "    $static  function staticGet(\$k,\$v=NULL) { " .
1075                     "return DB_DataObject::staticGet('{$this->classname}',\$k,\$v = null); }\n";
1076         }
1077         // generate getter and setter methods
1078         $body .= $this->_generateGetters($input);
1079         $body .= $this->_generateSetters($input);
1080         $body .= $this->_generateLinkMethods($input);
1081         /*
1082         theoretically there is scope here to introduce 'list' methods
1083         based up 'xxxx_up' column!!! for heiracitcal trees..
1084         */
1085
1086         // set methods
1087         //foreach ($sets as $k=>$v) {
1088         //    $kk = strtoupper($k);
1089         //    $body .="    function getSets{$k}() { return {$v}; }\n";
1090         //}
1091
1092         if (!empty($options['generator_no_ini'])) {
1093             $def = $this->_generateDefinitionsTable();  // simplify this!?
1094             $body .= $this->_generateTableFunction($def['table']);
1095             $body .= $this->_generateKeysFunction($def['keys']);
1096             $body .= $this->_generateSequenceKeyFunction($def);
1097             $body .= $this->_generateDefaultsFunction($this->table, $def['table']);
1098         }  else if (!empty($options['generator_add_defaults'])) {
1099             // I dont really like doing it this way (adding another option)
1100             // but it helps on older projects.
1101             $def = $this->_generateDefinitionsTable();  // simplify this!?
1102             $body .= $this->_generateDefaultsFunction($this->table,$def['table']);
1103
1104         }
1105         $body .= $this->derivedHookFunctions($input);
1106
1107         $body .= "\n    /* the code above is auto generated do not remove the tag below */";
1108         $body .= "\n    ###END_AUTOCODE\n";
1109
1110
1111         // stubs..
1112
1113         if (!empty($options['generator_add_validate_stubs'])) {
1114             foreach($defs as $t) {
1115                 if (!strlen(trim($t->name))) {
1116                     continue;
1117                 }
1118                 $validate_fname = 'validate' . $this->getMethodNameFromColumnName($t->name);
1119                 // dont re-add it..
1120                 if (preg_match('/\s+function\s+' . $validate_fname . '\s*\(/i', $input)) {
1121                     continue;
1122                 }
1123                 $body .= "\n    function {$validate_fname}()\n    {\n        return false;\n    }\n";
1124             }
1125         }
1126
1127
1128
1129
1130         $foot .= "}\n";
1131         $full = $head . $body . $foot;
1132
1133         if (!$input) {
1134             return $full;
1135         }
1136         if (!preg_match('/(\n|\r\n)\s*###START_AUTOCODE(\n|\r\n)/s',$input))  {
1137             return $full;
1138         }
1139         if (!preg_match('/(\n|\r\n)\s*###END_AUTOCODE(\n|\r\n)/s',$input)) {
1140             return $full;
1141         }
1142
1143
1144         /* this will only replace extends DB_DataObject by default,
1145             unless use set generator_class_rewrite to ANY or a name*/
1146
1147         $class_rewrite = 'DB_DataObject';
1148         $options = &PEAR::getStaticProperty('DB_DataObject','options');
1149         if (empty($options['generator_class_rewrite']) || !($class_rewrite = $options['generator_class_rewrite'])) {
1150             $class_rewrite = 'DB_DataObject';
1151         }
1152         if ($class_rewrite == 'ANY') {
1153             $class_rewrite = '[a-z_]+';
1154         }
1155
1156         $input = preg_replace(
1157             '/(\n|\r\n)class\s*[a-z0-9_]+\s*extends\s*' .$class_rewrite . '\s*(\n|\r\n)\{(\n|\r\n)/si',
1158             "\nclass {$this->classname} extends {$this->_extends} \n{\n",
1159             $input);
1160
1161         $ret =  preg_replace(
1162             '/(\n|\r\n)\s*###START_AUTOCODE(\n|\r\n).*(\n|\r\n)\s*###END_AUTOCODE(\n|\r\n)/s',
1163             $body,$input);
1164
1165         if (!strlen($ret)) {
1166             return PEAR::raiseError(
1167                 "PREG_REPLACE failed to replace body, - you probably need to set these in your php.ini\n".
1168                 "pcre.backtrack_limit=1000000\n".
1169                 "pcre.recursion_limit=1000000\n"
1170                 ,null, PEAR_ERROR_DIE);
1171        }
1172
1173         return $ret;
1174     }
1175
1176     /**
1177      * hook to add extra methods to all classes
1178      *
1179      * called once for each class, use with $this->table and
1180      * $this->_definitions[$this->table], to get data out of the current table,
1181      * use it to add extra methods to the default classes.
1182      *
1183      * @access   public
1184      * @return  string added to class eg. functions.
1185      */
1186     function derivedHookFunctions($input = "")
1187     {
1188         // This is so derived generator classes can generate functions
1189         // It MUST NOT be changed here!!!
1190         return "";
1191     }
1192
1193     /**
1194      * hook for var lines
1195      * called each time a var line is generated, override to add extra var
1196      * lines
1197      *
1198      * @param object t containing type,len,flags etc. from tableInfo call
1199      * @param int padding number of spaces
1200      * @access   public
1201      * @return  string added to class eg. functions.
1202      */
1203     function derivedHookVar(&$t,$padding)
1204     {
1205         // This is so derived generator classes can generate variabels
1206         // It MUST NOT be changed here!!!
1207         return "";
1208     }
1209     /**
1210      * hook for after var lines (
1211      * called at the end of the output of var line have generated, override to add extra var
1212      * lines
1213      *
1214      * @param array cols containing array of objects with type,len,flags etc. from tableInfo call
1215      * @access   public
1216      * @return  string added to class eg. functions.
1217      */
1218     function derivedHookPostVar($t)
1219     {
1220         // This is so derived generator classes can generate variabels
1221         // It MUST NOT be changed here!!!
1222         return "";
1223     }
1224     /**
1225      * hook to add extra page-level (in terms of phpDocumentor) DocBlock
1226      *
1227      * called once for each class, use it add extra page-level docs
1228      * @access public
1229      * @return string added to class eg. functions.
1230      */
1231     function derivedHookPageLevelDocBlock() {
1232         return '';
1233     }
1234
1235     /**
1236      * hook to add extra doc block (in terms of phpDocumentor) to extend string
1237      *
1238      * called once for each class, use it add extra comments to extends
1239      * string (require_once...)
1240      * @access public
1241      * @return string added to class eg. functions.
1242      */
1243     function derivedHookExtendsDocBlock() {
1244         return '';
1245     }
1246
1247     /**
1248      * hook to add extra class level DocBlock (in terms of phpDocumentor)
1249      *
1250      * called once for each class, use it add extra comments to class
1251      * string (require_once...)
1252      * @access public
1253      * @return string added to class eg. functions.
1254      */
1255     function derivedHookClassDocBlock() {
1256         return '';
1257     }
1258
1259     /**
1260
1261     /**
1262     * getProxyFull - create a class definition on the fly and instantate it..
1263     *
1264     * similar to generated files - but also evals the class definitoin code.
1265     *
1266     *
1267     * @param   string database name
1268     * @param   string  table   name of table to create proxy for.
1269     *
1270     *
1271     * @return   object    Instance of class. or PEAR Error
1272     * @access   public
1273     */
1274     function getProxyFull($database,$table)
1275     {
1276
1277         if ($err = $this->fillTableSchema($database,$table)) {
1278             return $err;
1279         }
1280
1281
1282         $options = &PEAR::getStaticProperty('DB_DataObject','options');
1283         $class_prefix  = empty($options['class_prefix']) ? '' : $options['class_prefix'];
1284
1285         $this->_extends = empty($options['extends']) ? $this->_extends : $options['extends'];
1286         $this->_extendsFile = empty($options['extends_location']) ? $this->_extendsFile : $options['extends_location'];
1287
1288         $classname = $this->classname = $this->getClassNameFromTableName($this->table);
1289
1290         $out = $this->_generateClassTable();
1291         //echo $out;
1292         eval('?>'.$out);
1293         return new $classname;
1294
1295     }
1296
1297      /**
1298     * fillTableSchema - set the database schema on the fly
1299     *
1300     *
1301     *
1302     * @param   string database name
1303     * @param   string  table   name of table to create schema info for
1304     *
1305     * @return   none | PEAR::error()
1306     * @access   public
1307     */
1308     function fillTableSchema($database,$table)
1309     {
1310         global $_DB_DATAOBJECT;
1311          // a little bit of sanity testing.
1312         if ((false !== strpos($database,"'")) || (false !== strpos($database,";"))) {
1313             return PEAR::raiseError("Error: Database name contains a quote or semi-colon", null, PEAR_ERROR_DIE);
1314         }
1315
1316         $this->_database  = $database;
1317
1318         $this->_connect();
1319         $table = trim($table);
1320
1321         // a little bit of sanity testing.
1322         if ((false !== strpos($table,"'")) || (false !== strpos($table,";"))) {
1323             return PEAR::raiseError("Error: Table contains a quote or semi-colon", null, PEAR_ERROR_DIE);
1324         }
1325         $__DB= &$GLOBALS['_DB_DATAOBJECT']['CONNECTIONS'][$this->_database_dsn_md5];
1326
1327
1328         $options   = PEAR::getStaticProperty('DB_DataObject','options');
1329         $db_driver = empty($options['db_driver']) ? 'DB' : $options['db_driver'];
1330         $is_MDB2   = ($db_driver != 'DB') ? true : false;
1331
1332         if (!$is_MDB2) {
1333             // try getting a list of schema tables first. (postgres)
1334             $__DB->expectError(DB_ERROR_UNSUPPORTED);
1335             $this->tables = $__DB->getListOf('schema.tables');
1336             $__DB->popExpect();
1337         } else {
1338             /**
1339              * set portability and some modules to fetch the informations
1340              */
1341             $__DB->setOption('portability', MDB2_PORTABILITY_ALL ^ MDB2_PORTABILITY_FIX_CASE);
1342             $__DB->loadModule('Manager');
1343             $__DB->loadModule('Reverse');
1344         }
1345         $quotedTable = !empty($options['quote_identifiers_tableinfo']) ?
1346                 $__DB->quoteIdentifier($table) : $table;
1347
1348         if (!$is_MDB2) {
1349             $defs =  $__DB->tableInfo($quotedTable);
1350         } else {
1351             $defs =  $__DB->reverse->tableInfo($quotedTable);
1352             foreach ($defs as $k => $v) {
1353                 if (!isset($defs[$k]['length'])) {
1354                     continue;
1355                 }
1356                 $defs[$k]['len'] = $defs[$k]['length'];
1357             }
1358         }
1359
1360
1361
1362
1363         if (PEAR::isError($defs)) {
1364             return $defs;
1365         }
1366         if (@$_DB_DATAOBJECT['CONFIG']['debug'] > 2) {
1367             $this->debug("getting def for $database/$table",'fillTable');
1368             $this->debug(print_r($defs,true),'defs');
1369         }
1370         // cast all definitions to objects - as we deal with that better.
1371
1372
1373         foreach($defs as $def) {
1374             if (is_array($def)) {
1375                 $this->_definitions[$table][] = (object) $def;
1376             }
1377         }
1378
1379         $this->table = trim($table);
1380         $ret = $this->_generateDefinitionsTable();
1381
1382         $_DB_DATAOBJECT['INI'][$database][$table] = $ret['table'];
1383         $_DB_DATAOBJECT['INI'][$database][$table.'__keys'] = $ret['keys'];
1384         return false;
1385
1386     }
1387
1388     /**
1389     * Generate getter methods for class definition
1390     *
1391     * @param    string  $input  Existing class contents
1392     * @return   string
1393     * @access   public
1394     */
1395     function _generateGetters($input)
1396     {
1397
1398         $options = &PEAR::getStaticProperty('DB_DataObject','options');
1399         $getters = '';
1400
1401         // only generate if option is set to true
1402         if  (empty($options['generate_getters'])) {
1403             return '';
1404         }
1405
1406         // remove auto-generated code from input to be able to check if the method exists outside of the auto-code
1407         $input = preg_replace('/(\n|\r\n)\s*###START_AUTOCODE(\n|\r\n).*(\n|\r\n)\s*###END_AUTOCODE(\n|\r\n)/s', '', $input);
1408
1409         $getters .= "\n\n";
1410         $defs     = $this->_definitions[$this->table];
1411
1412         // loop through properties and create getter methods
1413         foreach ($defs = $defs as $t) {
1414
1415             // build mehtod name
1416             $methodName = 'get' . $this->getMethodNameFromColumnName($t->name);
1417
1418             if (!strlen(trim($t->name)) || preg_match("/function[\s]+[&]?$methodName\(/i", $input)) {
1419                 continue;
1420             }
1421
1422             $getters .= "   /**\n";
1423             $getters .= "    * Getter for \${$t->name}\n";
1424             $getters .= "    *\n";
1425             $getters .= (stristr($t->flags, 'multiple_key')) ? "    * @return   object\n"
1426                                                              : "    * @return   {$t->type}\n";
1427             $getters .= "    * @access   public\n";
1428             $getters .= "    */\n";
1429             $getters .= (substr(phpversion(),0,1) > 4) ? '    public '
1430                                                        : '    ';
1431             $getters .= "function $methodName() {\n";
1432             $getters .= "        return \$this->{$t->name};\n";
1433             $getters .= "    }\n\n";
1434         }
1435
1436
1437         return $getters;
1438     }
1439     /**
1440     * Generate link setter/getter methods for class definition
1441     *
1442     * @param    string  Existing class contents
1443     * @return   string
1444     * @access   public
1445     */
1446     function _generateLinkMethods($input)
1447     {
1448
1449         $options = &PEAR::getStaticProperty('DB_DataObject','options');
1450         $setters = '';
1451
1452         // only generate if option is set to true
1453
1454         // generate_link_methods true::
1455
1456
1457         if  (empty($options['generate_link_methods'])) {
1458             //echo "skip lm? - not set";
1459             return '';
1460         }
1461
1462         if (empty($this->_fkeys)) {
1463             // echo "skip lm? - fkyes empty";
1464             return '';
1465         }
1466         if (empty($this->_fkeys[$this->table])) {
1467             //echo "skip lm? - no fkeys for {$this->table}";
1468             return '';
1469         }
1470
1471         // remove auto-generated code from input to be able to check if the method exists outside of the auto-code
1472         $input = preg_replace('/(\n|\r\n)\s*###START_AUTOCODE(\n|\r\n).*(\n|\r\n)\s*###END_AUTOCODE(\n|\r\n)/s', '', $input);
1473
1474         $setters .= "\n";
1475         $defs     = $this->_fkeys[$this->table];
1476
1477
1478         // $fk[$this->table][$tref[1]] = $tref[2] . ":" . $tref[3];
1479
1480         // loop through properties and create setter methods
1481         foreach ($defs as $k => $info) {
1482
1483             // build mehtod name
1484             $methodName =  is_callable($options['generate_link_methods']) ?
1485                     $options['generate_link_methods']($k) : $k;
1486
1487             if (!strlen(trim($k)) || preg_match("/function[\s]+[&]?$methodName\(/i", $input)) {
1488                 continue;
1489             }
1490
1491             $setters .= "   /**\n";
1492             $setters .= "    * Getter / Setter for \${$k}\n";
1493             $setters .= "    *\n";
1494             $setters .= "    * @param    mixed   (optional) value to assign\n";
1495             $setters .= "    * @access   public\n";
1496
1497             $setters .= "    */\n";
1498             $setters .= (substr(phpversion(),0,1) > 4) ? '    public '
1499                                                        : '    ';
1500             $setters .= "function $methodName() {\n";
1501             $setters .= "        return \$this->link('$k', func_get_args());\n";
1502             $setters .= "    }\n\n";
1503         }
1504
1505         return $setters;
1506     }
1507
1508    /**
1509     * Generate setter methods for class definition
1510     *
1511     * @param    string  Existing class contents
1512     * @return   string
1513     * @access   public
1514     */
1515     function _generateSetters($input)
1516     {
1517
1518         $options = &PEAR::getStaticProperty('DB_DataObject','options');
1519         $setters = '';
1520
1521         // only generate if option is set to true
1522         if  (empty($options['generate_setters'])) {
1523             return '';
1524         }
1525
1526         // remove auto-generated code from input to be able to check if the method exists outside of the auto-code
1527         $input = preg_replace('/(\n|\r\n)\s*###START_AUTOCODE(\n|\r\n).*(\n|\r\n)\s*###END_AUTOCODE(\n|\r\n)/s', '', $input);
1528
1529         $setters .= "\n";
1530         $defs     = $this->_definitions[$this->table];
1531
1532         // loop through properties and create setter methods
1533         foreach ($defs = $defs as $t) {
1534
1535             // build mehtod name
1536             $methodName = 'set' . $this->getMethodNameFromColumnName($t->name);
1537
1538             if (!strlen(trim($t->name)) || preg_match("/function[\s]+[&]?$methodName\(/i", $input)) {
1539                 continue;
1540             }
1541
1542             $setters .= "   /**\n";
1543             $setters .= "    * Setter for \${$t->name}\n";
1544             $setters .= "    *\n";
1545             $setters .= "    * @param    mixed   input value\n";
1546             $setters .= "    * @access   public\n";
1547             $setters .= "    */\n";
1548             $setters .= (substr(phpversion(),0,1) > 4) ? '    public '
1549                                                        : '    ';
1550             $setters .= "function $methodName(\$value) {\n";
1551             $setters .= "        \$this->{$t->name} = \$value;\n";
1552             $setters .= "    }\n\n";
1553         }
1554
1555
1556         return $setters;
1557     }
1558     /**
1559     * Generate table Function - used when generator_no_ini is set.
1560     *
1561     * @param    array  table array.
1562     * @return   string
1563     * @access   public
1564     */
1565     function _generateTableFunction($def)
1566     {
1567         $defines = explode(',','INT,STR,DATE,TIME,BOOL,TXT,BLOB,NOTNULL,MYSQLTIMESTAMP');
1568
1569         $ret = "\n" .
1570                "    function table()\n" .
1571                "    {\n" .
1572                "         return array(\n";
1573
1574         foreach($def as $k=>$v) {
1575             $str = '0';
1576             foreach($defines as $dn) {
1577                 if ($v & constant('DB_DATAOBJECT_' . $dn)) {
1578                     $str .= ' + DB_DATAOBJECT_' . $dn;
1579                 }
1580             }
1581             if (strlen($str) > 1) {
1582                 $str = substr($str,3); // strip the 0 +
1583             }
1584             // hopefully addslashes is good enough here!!!
1585             $ret .= '             \''.addslashes($k).'\' => ' . $str . ",\n";
1586         }
1587         return $ret . "         );\n" .
1588                       "    }\n";
1589
1590
1591
1592     }
1593     /**
1594     * Generate keys Function - used generator_no_ini is set.
1595     *
1596     * @param    array  keys array.
1597     * @return   string
1598     * @access   public
1599     */
1600     function _generateKeysFunction($def)
1601     {
1602
1603         $ret = "\n" .
1604                "    function keys()\n" .
1605                "    {\n" .
1606                "         return array(";
1607
1608         foreach($def as $k=>$type) {
1609             // hopefully addslashes is good enough here!!!
1610             $ret .= '\''.addslashes($k).'\', ';
1611         }
1612         $ret = preg_replace('#, $#', '', $ret);
1613         return $ret . ");\n" .
1614                       "    }\n";
1615
1616
1617
1618     }
1619     /**
1620     * Generate sequenceKey Function - used generator_no_ini is set.
1621     *
1622     * @param    array  table and key definition.
1623     * @return   string
1624     * @access   public
1625     */
1626     function _generateSequenceKeyFunction($def)
1627     {
1628
1629         //print_r($def);
1630         // DB_DataObject::debugLevel(5);
1631         global $_DB_DATAOBJECT;
1632         // print_r($def);
1633
1634
1635         $dbtype     = $_DB_DATAOBJECT['CONNECTIONS'][$this->_database_dsn_md5]->dsn['phptype'];
1636         $realkeys   = $def['keys'];
1637         $keys       = array_keys($realkeys);
1638         $usekey     = isset($keys[0]) ? $keys[0] : false;
1639         $table      = $def['table'];
1640
1641
1642         $seqname = false;
1643
1644
1645
1646
1647         $ar = array(false,false,false);
1648         if ($usekey !== false) {
1649             if (!empty($_DB_DATAOBJECT['CONFIG']['sequence_'.$this->__table])) {
1650                 $usekey = $_DB_DATAOBJECT['CONFIG']['sequence_'.$this->__table];
1651                 if (strpos($usekey,':') !== false) {
1652                     list($usekey,$seqname) = explode(':',$usekey);
1653                 }
1654             }
1655
1656             if (in_array($dbtype , array( 'mysql', 'mysqli', 'mssql', 'ifx')) &&
1657                 ($table[$usekey] & DB_DATAOBJECT_INT) &&
1658                 isset($realkeys[$usekey]) && ($realkeys[$usekey] == 'N')
1659                 ) {
1660                 // use native sequence keys.
1661                 $ar =  array($usekey,true,$seqname);
1662             } else {
1663                 // use generated sequence keys..
1664                 if ($table[$usekey] & DB_DATAOBJECT_INT) {
1665                     $ar = array($usekey,false,$seqname);
1666                 }
1667             }
1668         }
1669
1670
1671
1672
1673         $ret = "\n" .
1674                "    function sequenceKey() // keyname, use native, native name\n" .
1675                "    {\n" .
1676                "         return array(";
1677         foreach($ar as $v) {
1678             switch (gettype($v)) {
1679                 case 'boolean':
1680                     $ret .= ($v ? 'true' : 'false') . ', ';
1681                     break;
1682
1683                 case 'string':
1684                     $ret .= "'" . $v . "', ";
1685                     break;
1686
1687                 default:    // eak
1688                     $ret .= "null, ";
1689
1690             }
1691         }
1692         $ret = preg_replace('#, $#', '', $ret);
1693         return $ret . ");\n" .
1694                       "    }\n";
1695
1696     }
1697     /**
1698     * Generate defaults Function - used generator_add_defaults or generator_no_ini is set.
1699     * Only supports mysql and mysqli ... welcome ideas for more..
1700     *
1701     *
1702     * @param    array  table and key definition.
1703     * @return   string
1704     * @access   public
1705     */
1706     function _generateDefaultsFunction($table,$defs)
1707     {
1708         $__DB= &$GLOBALS['_DB_DATAOBJECT']['CONNECTIONS'][$this->_database_dsn_md5];
1709         if (!in_array($__DB->phptype, array('mysql','mysqli'))) {
1710             return; // cant handle non-mysql introspection for defaults.
1711         }
1712         $options = PEAR::getStaticProperty('DB_DataObject','options');
1713         $db_driver = empty($options['db_driver']) ? 'DB' : $options['db_driver'];
1714         $method = $db_driver == 'DB' ? 'getAll' : 'queryAll';
1715         $res = $__DB->$method('DESCRIBE ' . $table,DB_FETCHMODE_ASSOC);
1716         $defaults = array();
1717         foreach($res as $ar) {
1718             // this is initially very dumb... -> and it may mess up..
1719             $type = $defs[$ar['Field']];
1720
1721             switch (true) {
1722
1723                 case (is_null( $ar['Default'])):
1724                     $defaults[$ar['Field']]  = 'null';
1725                     break;
1726
1727                 case ($type & DB_DATAOBJECT_DATE):
1728                 case ($type & DB_DATAOBJECT_TIME):
1729                 case ($type & DB_DATAOBJECT_MYSQLTIMESTAMP): // not supported yet..
1730                     break;
1731
1732                 case ($type & DB_DATAOBJECT_BOOL):
1733                     $defaults[$ar['Field']] = (int)(boolean) $ar['Default'];
1734                     break;
1735
1736
1737                 case ($type & DB_DATAOBJECT_STR):
1738                     $defaults[$ar['Field']] =  "'" . addslashes($ar['Default']) . "'";
1739                     break;
1740
1741
1742                 default:    // hopefully eveything else...  - numbers etc.
1743                     if (!strlen($ar['Default'])) {
1744                         continue;
1745                     }
1746                     if (is_numeric($ar['Default'])) {
1747                         $defaults[$ar['Field']] =   $ar['Default'];
1748                     }
1749                     break;
1750
1751             }
1752             //var_dump(array($ar['Field'], $ar['Default'], $defaults[$ar['Field']]));
1753         }
1754         if (empty($defaults)) {
1755             return;
1756         }
1757
1758         $ret = "\n" .
1759                "    function defaults() // column default values \n" .
1760                "    {\n" .
1761                "         return array(\n";
1762         foreach($defaults as $k=>$v) {
1763             $ret .= '             \''.addslashes($k).'\' => ' . $v . ",\n";
1764         }
1765         return $ret . "         );\n" .
1766                       "    }\n";
1767
1768
1769
1770
1771     }
1772
1773
1774
1775
1776
1777 }