<?php

/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */

/**
 * DB_Table_Generator - Generates DB_Table subclass skeleton code
 * 
 * Parts of this class were adopted from the DB_DataObject PEAR package.
 * 
 * PHP versions 4 and 5
 *
 * LICENSE:
 * 
 * Copyright (c) 1997-2007, Paul M. Jones <pmjones@php.net>
 *                          Alan Knowles <alan@akbkhome.com>
 *                          David C. Morse <morse@php.net>
 *                          Mark Wiesemann <wiesemann@php.net>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *    * Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *    * Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the 
 *      documentation and/or other materials provided with the distribution.
 *    * The names of the authors may not be used to endorse or promote products 
 *      derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * @category Database
 * @package  DB_Table
 * @author   Alan Knowles <alan@akbkhome.com> 
 * @author   David C. Morse <morse@php.net>
 * @license  http://opensource.org/licenses/bsd-license.php New BSD License
 * @version  CVS: $Id: Generator.php,v 1.17 2008/05/14 18:36:27 wiesemann Exp $
 * @link     http://pear.php.net/package/DB_Table
 */

// {{{ Includes

/**#@+
 * Include basic classes
 */
/**
 * The PEAR class (used for errors)
 */
require_once 'PEAR.php';

/**
 * DB_Table table abstraction class
 */
require_once 'DB/Table.php';

/**
 * DB_Table_Manager class (used to reverse engineer indices)
 */
require_once 'DB/Table/Manager.php';
/**#@-*/

// }}}
// {{{ Error code constants

/**#@+
 * Error codes
 */
/**
 * Parameter is not a DB/MDB2 object
 */
define('DB_TABLE_GENERATOR_ERR_DB_OBJECT', -301);

/**
 * Parameter is not a DB/MDB2 object
 */
define('DB_TABLE_GENERATOR_ERR_INDEX_COL', -302);

/**
 * Error while creating file/directory
 */
define('DB_TABLE_GENERATOR_ERR_FILE', -303);
/**#@-*/

// }}}
// {{{ Error messages
/**
 * US-English default error messages.
 */
$GLOBALS['_DB_TABLE_GENERATOR']['default_error'] = array(
        DB_TABLE_GENERATOR_ERR_DB_OBJECT =>
            'Invalid DB/MDB2 object parameter. Function',
        DB_TABLE_GENERATOR_ERR_INDEX_COL =>
            'Index column is not a valid column name. Index column',
        DB_TABLE_GENERATOR_ERR_FILE =>
            'Can\'t create file/directory:'
);

// merge default and user-defined error messages
if (!isset($GLOBALS['_DB_TABLE_GENERATOR']['error'])) {
    $GLOBALS['_DB_TABLE_GENERATOR']['error'] = array();
}
foreach ($GLOBALS['_DB_TABLE_GENERATOR']['default_error'] as $code => $message) {
    if (!array_key_exists($code, $GLOBALS['_DB_TABLE_GENERATOR']['error'])) {
        $GLOBALS['_DB_TABLE_GENERATOR']['error'][$code] = $message;
    }
}

// }}}
// {{{ class DB_Table_Generator

/**
 * class DB_Table_Generator - Generates DB_Table subclass skeleton code
 *
 * This class generates the php code necessary to use the DB_Table
 * package to interact with an existing database. This requires the
 * generation of a skeleton subclass definition be generated for each
 * table in the database, in which the $col, $idx, and $auto_inc_col
 * properties are constructed using a table schema that is obtained
 * by querying the database.
 *
 * The class can also generate a file, named 'Database.php' by default,
 * that includes (require_once) each of the table subclass definitions,
 * instantiates one object of each DB_Table subclass (i.e., one object
 * for each table), instantiates a parent DB_Table_Database object,
 * adds all the tables to that parent, attempts to guess foreign key
 * relationships between tables based on the column names, and adds
 * the inferred references to the parent object.
 *
 * All of the code is written to a directory whose path is given by
 * the property $class_write_path. By default, this is the current
 * directory.  By default, the name of the class constructed for a
 * table named 'thing' is "Thing_Table". That is, the class name is
 * the table name, with the first letter upper case, with a suffix
 * '_Table'.  This suffix can be changed by setting the $class_suffix
 * property. The file containing a subclass definition is the
 * subclass name with a php extension, e.g., 'Thing_Table.php'. The
 * object instantiated from that subclass is the same as the table
 * name, with no suffix, e.g., 'thing'.
 *
 * To generate the code for all of the tables in a database named
 * $database, instantiate a MDB2 or DB object named $db that connects
 * to the database of interest, and execute the following code:
 * <code>
 *     $generator = new DB_Table_Generator($db, $database);
 *     $generator->class_write_path = $class_write_path;
 *     $generator->generateTableClassFiles();
 *     $generator->generateDatabaseFile();
 * </code>
 * Here $class_write_path should be the path (without a trailing
 * separator) to a directory in which all of the code should be
 * written. If this directory does not exist, it will be created.
 * If the directory does already exist, exising files will not
 * be overwritten. If $class_write_path is not set (i.e., if this
 * line is omitted) all the code will be written to the current
 * directory.  If ->generateDatabaseFile() is called, it must be
 * called after ->generateTableClassFiles().
 *
 * By default, ->generateTableClassFiles() and ->generateDatabaseFiles()
 * generate code for all of the tables in the current database. To
 * generate code for a specified list of tables, set the value of the
 * public $tables property to a sequential list of table names before
 * calling either of these methods. Code can be generated for three
 * tables named 'table1', 'table2', and 'table3' as follows:
 * <code>
 *     $generator = new DB_Table_Generator($db, $database);
 *     $generator->class_write_path = $class_write_path;
 *     $generator->tables = array('table1', 'table2', 'table3');
 *     $generator->generateTableClassFiles();
 *     $generator->generateDatabaseFile();
 * </code>
 * If the $tables property is not set to a non-null value prior
 * to calling ->generateTableClassFiles() then, by default, the
 * database is queried for a list of all table names, by calling the
 * ->getTableNames() method from within ->generateTableClassFiles().
 *
 * PHP version 4 and 5
 *
 * @category Database
 * @package  DB_Table
 * @author   Alan Knowles <alan@akbkhome.com> 
 * @author   David C. Morse <morse@php.net>
 * @license  http://www.gnu.org/copyleft/lesser.html LGPL
 * @version  Release: 1.5.6
 * @link     http://pear.php.net/package/DB_Table
 */
class DB_Table_Generator
{

    // {{{ Properties

    /**
     * Name of the database
     *
     * @var string
     * @access public
     */
    var $name = null;

    /**
     * The PEAR DB/MDB2 object that connects to the database.
     *
     * @var object
     * @access private
     */
    var $db = null;

    /**
     * The backend type. May have values 'db' or 'mdb2'
     *
     * @var string
     * @access private
     */
    var $backend = null;

    /**
    * If there is an error on instantiation, this captures that error.
    *
    * This property is used only for errors encountered in the constructor
    * at instantiation time.  To check if there was an instantiation error...
    *
    * <code>
    *     $obj =& new DB_Table_Generator();
    *     if ($obj->error) {
    *         // ... error handling code here ...
    *     }
    * </code>
    *
    * @var object PEAR_Error
    * @access public
    */
    var $error = null;

    /**
     * Numerical array of table name strings
     *
     * @var array
     * @access public
     */
    var $tables = array();

    /**
     * Class being extended (DB_Table or generic subclass)
     *
     * @var string
     * @access public
     */
    var $extends = 'DB_Table';

    /**
     * Path to definition of the class $this->extends
     *
     * @var string
     * @access public
     */
    var $extends_file = 'DB/Table.php';

    /**
     * Suffix to add to table names to obtain corresponding class names
     *
     * @var string
     * @access public
     */
    var $class_suffix = "_Table";

    /**
     * Path to directory in which subclass definitions should be written
     *
     * Value should not include a trailing "/".
     *
     * @var string
     * @access public
     */
    var $class_write_path = '';

    /**
     * Include path to subclass definition files from database file
     *
     * Used to create require_once statements in the Database.php file,
     * which is in the same directory as the class definition files. Leave
     * as empty string if your PHP include_path contains ".". The value
     * should not include a trailing "/", which is added automatically
     * to values other than the empty string.
     *
     * @var string
     * @access public
     */
    var $class_include_path = '';

    /**
     * Array of column definitions
     *
     * Array $this->col[table_name][column_name] = column definition.
     * Column definition is an array with the same format as the $col
     * property of a DB_Table object
     *
     * @var array
     * @access public
     */
    var $col = array();

    /**
     * Array of index/constraint definitions.
     *
     * Array $this->idx[table_table][index_name] = Index definition.
     * The index definition is an array with the same format as the
     * DB_Table $idx property property array.
     *
     * @var array
     * @access public
     */
     var $idx = array();

    /**
     * Array of auto_increment column names
     *
     * Array $this->auto_inc_col[table_name] = auto-increment column
     *
     * @var array
     * @access public
     */
     var $auto_inc_col = array();

    /**
     * Array of primary keys
     *
     * @var array
     * @access public
     */
     var $primary_key = array();

    /**
     * MDB2 'idxname_format' option, format of index names
     *
     * For use in printf() formatting. Use '%s' to use index names as
     * returned by getTableConstraints/Indexes, and '%s_idx' to add an
     * '_idx' suffix. For MySQL, use the default value '%'.
     *
     * @var string
     * @access public
     */
    var $idxname_format = '%s';

    // }}}
    // {{{ function DB_Table_Generator(&$db, $name)

    /**
     * Constructor
     *
     * If an error is encountered during instantiation, the error
     * message is stored in the $this->error property of the resulting
     * object. See $error property docblock for a discussion of error
     * handling.
     *
     * @param object &$db  DB/MDB2 database connection object
     * @param string $name database name string
     *
     * @return object DB_Table_Generator
     * @access public
     */
    function __construct(&$db, $name)
    {
        // Is $db an DB/MDB2 object or null?
        if (is_a($db, 'db_common')) {
            $this->backend = 'db';
        } elseif (is_a($db, 'mdb2_driver_common')) {
            $this->backend = 'mdb2';
        } else {
            $this->error =&
                DB_Table_Generator::throwError(DB_TABLE_GENERATOR_ERR_DB_OBJECT,
                'DB_Table_Generator');
            return;
        }
        $this->db   =& $db;
        $this->name =  $name;

    }

    // }}}
    // {{{ function &throwError($code, $extra = null)

    /**
     * Specialized version of throwError() modeled on PEAR_Error.
     *
     * Throws a PEAR_Error with a DB_Table_Generator error message based
     * on a DB_Table_Generator constant error code.
     *
     * @param string $code  A DB_Table_Generator error code constant.
     * @param string $extra Extra text for the error (in addition to the
     *                       regular error message).
     *
     * @return object PEAR_Error
     * @access public
     * @static
     */
    function &throwError($code, $extra = null)
    {
        // get the error message text based on the error code
        $text = 'DB_TABLE_GENERATOR ERROR - ' . "\n"
              . $GLOBALS['_DB_TABLE_GENERATOR']['error'][$code];

        // add any additional error text
        if ($extra) {
            $text .= ' ' . $extra;
        }

        // done!
        $error = PEAR::throwError($text, $code);
        return $error;
    }

    // }}}
    // {{{ function setErrorMessage($code, $message = null)

    /**
     * Overwrites one or more error messages, e.g., to internationalize them.
     *
     * @param mixed  $code    If string, the error message with code $code will be
     *                        overwritten by $message. If array, each key is a
     *                        code and each value is a new message.
     * @param string $message Only used if $key is not an array.
     *
     * @return void
     * @access public
     */
    function setErrorMessage($code, $message = null)
    {
        if (is_array($code)) {
            foreach ($code as $single_code => $single_message) {
                $GLOBALS['_DB_TABLE_GENERATOR']['error'][$single_code]
                    = $single_message;
            }
        } else {
            $GLOBALS['_DB_TABLE_GENERATOR']['error'][$code] = $message;
        }
    }

    // }}}
    // {{{ function getTableNames()

    /**
     * Gets a list of tables from the database
     *
     * Upon successful completion, names are stored in the $this->tables
     * array. If an error is encountered, a PEAR Error is returned, and
     * $this->tables is reset to null.
     *
     * @return mixed true on success, PEAR Error on failure
     * @access public
     */
    function getTableNames()
    {

        if ($this->backend == 'db') {
            // try getting a list of schema tables first. (postgres)
            $this->db->expectError(DB_ERROR_UNSUPPORTED);
            $this->tables = $this->db->getListOf('schema.tables');
            $this->db->popExpect();
            if (PEAR::isError($this->tables)) {
                // try a list of tables, not qualified by 'schema'
                $this->db->expectError(DB_ERROR_UNSUPPORTED);
                $this->tables = $this->db->getListOf('tables');
                $this->db->popExpect();
            }
        } else {
            // Temporarily change 'portability' MDB2 option
            $portability = $this->db->getOption('portability');
            $this->db->setOption('portability',
                MDB2_PORTABILITY_ALL ^ MDB2_PORTABILITY_FIX_CASE);

            $this->db->loadModule('Manager');
            $this->db->loadModule('Reverse');

            // Get list of tables
            $this->tables = $this->db->manager->listTables();

            // Restore original MDB2 'portability'
            $this->db->setOption('portability', $portability);
        }
        if (PEAR::isError($this->tables)) {
            $error        = $this->tables;
            $this->tables = null;
            return $error;
        } else {
            $this->tables = array_map(array($this, 'tableName'),
                                      $this->tables);
            return true;
        }
    }

    // }}}
    // {{{ function getTableDefinition($table)

    /**
     * Gets column and index definitions by querying database
     *
     * Upon return, column definitions are stored in $this->col[$table],
     * and index definitions in $this->idx[$table].
     *
     * Calls DB/MDB2::tableInfo() for column definitions, and uses
     * the DB_Table_Manager class to obtain index definitions.
     *
     * @param string $table name of table
     *
     * @return mixed true on success, PEAR Error on failure
     * @access public
     */
    function getTableDefinition($table)
    {
        /*
        // postgres strip the schema bit from the
        if (!empty($options['generator_strip_schema'])) {
            $bits = explode('.', $table,2);
            $table = $bits[0];
            if (count($bits) > 1) {
                $table = $bits[1];
            }
        }
        */

        if ($this->backend == 'db') {

            $defs = $this->db->tableInfo($table);
            if (PEAR::isError($defs)) {
                return $defs;
            }
            $this->columns[$table] = $defs;

        } else {

            // Temporarily change 'portability' MDB2 option
            $portability = $this->db->getOption('portability');
            $this->db->setOption('portability',
                MDB2_PORTABILITY_ALL ^ MDB2_PORTABILITY_FIX_CASE);

            $this->db->loadModule('Manager');
            $this->db->loadModule('Reverse');

            // Columns
            $defs = $this->db->reverse->tableInfo($table);
            if (PEAR::isError($defs)) {
                return $defs;
            }

            // rename the 'length' key, so it matches db's return.
            foreach ($defs as $k => $v) {
                if (isset($defs[$k]['length'])) {
                    $defs[$k]['len'] = $defs[$k]['length'];
                }
            }

            $this->columns[$table] = $defs;

            // Temporarily set 'idxname_format' MDB2 option to $this->idx_format
            $idxname_format = $this->db->getOption('idxname_format');
            $this->db->setOption('idxname_format', $this->idxname_format);
        }

        // Default - no auto increment column
        $this->auto_inc_col[$table] = null;

        // Loop over columns to create $this->col[$table]
        $this->col[$table] = array();
        foreach ($defs as $t) {

            $name = $t['name'];
            $col  = array();

            switch (strtoupper($t['type'])) {
            case 'INT2':     // postgres
            case 'TINYINT':
            case 'TINY':     //mysql
            case 'SMALLINT':
                $col['type'] = 'smallint';
                break;
            case 'INT4':      // postgres
            case 'SERIAL4':   // postgres
            case 'INT':
            case 'SHORT':     // mysql
            case 'INTEGER':
            case 'MEDIUMINT':
            case 'YEAR':
                $col['type'] = 'integer';
                break;
            case 'BIGINT':
            case 'LONG':    // mysql
            case 'INT8':    // postgres
            case 'SERIAL8': // postgres
                $col['type'] = 'bigint';
                break;
            case 'REAL':
            case 'NUMERIC':
            case 'NUMBER': // oci8
            case 'FLOAT':  // mysql
            case 'FLOAT4': // real (postgres)
                $col['type'] = 'single';
                break;
            case 'DOUBLE':
            case 'DOUBLE PRECISION': // double precision (firebird)
            case 'FLOAT8':           // double precision (postgres)
                $col['type'] = 'double';
                break;
            case 'DECIMAL':
            case 'MONEY':   // mssql and maybe others
                $col['type'] = 'decimal';
                break;
            case 'BIT':
            case 'BOOL':
            case 'BOOLEAN':
                $col['type'] = 'boolean';
                break;
            case 'STRING':
            case 'CHAR':
                $col['type'] = 'char';
                break;
            case 'VARCHAR':
            case 'VARCHAR2':
            case 'TINYTEXT':
                $col['type'] = 'varchar';
                break;
            case 'TEXT':
            case 'MEDIUMTEXT':
            case 'LONGTEXT':
                $col['type'] = 'clob';
                break;
            case 'DATE':
                $col['type'] = 'date';
                break;
            case 'TIME':
                $col['type'] = 'time';
                break;
            case 'DATETIME':  // mysql
            case 'TIMESTAMP':
                $col['type'] = 'timestamp';
                break;
            case 'ENUM':
            case 'SET':         // not really but oh well
            case 'TIMESTAMPTZ': // postgres
            case 'BPCHAR':      // postgres
            case 'INTERVAL':    // postgres (eg. '12 days')
            case 'CIDR':        // postgres IP net spec
            case 'INET':        // postgres IP
            case 'MACADDR':     // postgress network Mac address.
            case 'INTEGER[]':   // postgres type
            case 'BOOLEAN[]':   // postgres type
                $col['type'] = 'varchar';
                break;
            default:
                $col['type'] = $t['type'] . ' (Unknown type)';
                break;
            }

            // Set length and scope if required
            if (in_array($col['type'], array('char','varchar','decimal'))) {
                if (isset($t['len'])) {
                    $col['size'] = (int) $t['len'];
                } elseif ($col['type'] == 'varchar') {
                    $col['size'] = 255; // default length
                } elseif ($col['type'] == 'char') {
                    $col['size'] = 128; // default length
                } elseif ($col['type'] == 'decimal') {
                    $col['size'] = 15; // default length
                }
                if ($col['type'] == 'decimal') {
                    $col['scope'] = 2;
                }
            }
            if (isset($t['notnull'])) {
                if ($t['notnull']) {
                    $col['require'] = true;
                }
            }
            if (isset($t['autoincrement'])) {
                $this->auto_inc_col[$table] = $name;
            }
            if (isset($t['flags'])) {
                $flags = $t['flags'];
                if (preg_match('/not[ _]null/i', $flags)) {
                    $col['require'] = true;
                }
                if (preg_match("/(auto_increment|nextval\()/i", $flags)) {
                    $this->auto_inc_col[$table] = $name;
                }
            }
            $require = isset($col['require']) ? $col['require'] : false;
            if ($require) {
                if (isset($t['default'])) {
                    $default = $t['default'];
                    $type    = $col['type'];
                    if (in_array($type,
                                 array('smallint', 'integer', 'bigint'))) {
                        $default = (int) $default;
                    } elseif (in_array($type, array('single', 'double'))) {
                        $default = (float) $default;
                    } elseif ($type == 'boolean') {
                        $default = (int) $default ? 1 : 0;
                    }
                    $col['default'] = $default;
                }
            }
            $this->col[$table][$name] = $col;

        }

        // Make array with lower case column array names as keys
        $col_lc = array();
        foreach ($this->col[$table] as $name => $def) {
            $name_lc          = strtolower($name);
            $col_lc[$name_lc] = $name;
        }

        // Constraints/Indexes
        $DB_indexes = DB_Table_Manager::getIndexes($this->db, $table);
        if (PEAR::isError($DB_indexes)) {
            return $DB_indexes;
        }

        // Check that index columns correspond to valid column names.
        // Try to correct problems with capitalization, if necessary.
        foreach ($DB_indexes as $type => $indexes) {
            foreach ($indexes as $name => $fields) {
                foreach ($fields as $key => $field) {

                    // If index column is not a valid column name
                    if (!array_key_exists($field, $this->col[$table])) {

                        // Try a case-insensitive match
                        $field_lc = strtolower($field);
                        if (isset($col_lc[$field_lc])) {
                            $correct = $col_lc[$field_lc];
                            $DB_indexes[$type][$name][$key]
                                 = $correct;
                        } else {
                            $code   =  DB_TABLE_GENERATOR_ERR_INDEX_COL;
                            $return =&
                                DB_Table_Generator::throwError($code, $field);
                        }

                    }
                }
            }
        }

        // Generate index definitions, if any, as php code
        $n_idx = 0;
        $u     = array();

        $this->idx[$table]         = array();
        $this->primary_key[$table] = null;
        foreach ($DB_indexes as $type => $indexes) {
            if (count($indexes) > 0) {
                foreach ($indexes as $name => $fields) {
                    $this->idx[$table][$name]         = array();
                    $this->idx[$table][$name]['type'] = $type;
                    if (count($fields) == 1) {
                        $key = $fields[0];
                    } else {
                        $key = array();
                        foreach ($fields as $value) {
                            $key[] = $value;
                        }
                    }
                    $this->idx[$table][$name]['cols'] = $key;
                    if ($type == 'primary') {
                        $this->primary_key[$table] = $key;
                    }
                }
            }
        }

        if ($this->backend == 'mdb2') {
            // Restore original MDB2 'idxname_format' and 'portability'
            $this->db->setOption('idxname_format', $idxname_format);
            $this->db->setOption('portability', $portability);
        }

        return true;
    }

    // }}}
    // {{{ function buildTableClass($table, $indent = '')

    /**
     * Returns one skeleton DB_Table subclass definition, as php code
     *
     * The returned subclass definition string contains values for the
     * $col (column), $idx (index) and $auto_inc_col properties, with
     * no method definitions.
     *
     * @param string $table  name of table
     * @param string $indent string of whitespace for base indentation
     *
     * @return string skeleton DB_Table subclass definition
     * @access public
     */
    function buildTableClass($table, $indent = '')
    {
        $s   = array();
        $idx = array();
        $u   = array();
        $v   = array();
        $l   = 0;

        $s[]     = $indent . '/*';
        $s[]     = $indent . ' * Create the table object';
        $s[]     = $indent . ' */';
        $s[]     = $indent . 'class ' . $this->className($table)
                 . " extends {$this->extends} {\n";
        $indent .= '    ';

        $s[]     = $indent . '/*';
        $s[]     = $indent . ' * Column definitions';
        $s[]     = $indent . ' */';
        $s[]     = $indent . 'var $col = array(' . "\n";
        $indent .= '    ';

        // Begin loop over columns
        foreach ($this->col[$table] as $name => $col) {

            // Generate DB_Table column definitions as php code
            $t  = array();
            $t1 = array();
            $l1 = 0;

            $name     = $indent . "'{$name}'";
            $l        = max($l, strlen($name));
            $v[$name] = "array(\n";
            $indent  .= '    ';
            foreach ($col as $key => $value) {
                if (is_string($value)) {
                    $value = "'{$value}'";
                } elseif (is_bool($value)) {
                    $value = $value ? 'true' : 'false';
                } else {
                    $value = (string) $value;
                }
                $l1   = max($l1, strlen($key) + 2);
                $t1[] = array("'{$key}'", $value) ;
            }
            foreach ($t1 as $value) {
                $t[] = $indent . str_pad($value[0], $l1, ' ', STR_PAD_RIGHT)
                     . ' => ' . $value[1];
            }
            $v[$name] .= implode(",\n", $t) . "\n";
            $indent    = substr($indent, 0, -4);
            $v[$name] .= $indent . ')';
        } //end loop over columns

        foreach ($v as $key => $value) {
            $u[] = str_pad($key, $l, ' ', STR_PAD_RIGHT)
                 . ' => ' . $value;
        }
        $s[]    = implode(",\n\n", $u) . "\n";
        $indent = substr($indent, 0, -4);
        $s[]    = $indent . ");\n";

        // Generate index definitions, if any, as php code
        if (count($this->idx[$table]) > 0) {
            $u = array();
            $v = array();
            $l = 0;

            $s[]     = $indent . '/*';
            $s[]     = $indent . ' * Index definitions';
            $s[]     = $indent . ' */';
            $s[]     = $indent . 'var $idx = array(' . "\n";
            $indent .= '    ';
            foreach ($this->idx[$table] as $name => $def) {
                $type      = $def['type'];
                $cols      = $def['cols'];
                $name      = $indent . "'{$name}'";
                $l         = max($l, strlen($name));
                $v[$name]  = "array(\n";
                $indent   .= '    ';
                $v[$name] .= $indent . "'type' => '{$type}',\n";
                if (is_array($cols)) {
                    $v[$name] .= $indent . "'cols' => array(\n";
                    $indent   .= '    ';
                    $t         = array();
                    foreach ($cols as $value) {
                        $t[] = $indent . "'{$value}'";
                    }
                    $v[$name] .= implode(",\n", $t) . "\n";
                    $indent    = substr($indent, 0, -4);
                    $v[$name] .= $indent . ")\n";
                } else {
                    $v[$name] = $v[$name] . $indent . "'cols' => '{$cols}'\n";
                }
                $indent    = substr($indent, 0, -4);
                $v[$name] .= $indent . ")";
            }

            foreach ($v as $key => $value) {
                $u[] = str_pad($key, $l, ' ', STR_PAD_RIGHT)
                     . ' => ' . $value;
            }
            $s[]    = implode(",\n\n", $u) . "\n";
            $indent = substr($indent, 0, -4);
            $s[]    = $indent . ");\n";
        } // end index generation

        // Write auto_inc_col
        if (isset($this->auto_inc_col[$table])) {
            $s[] = $indent . '/*';
            $s[] = $indent . ' * Auto-increment declaration';
            $s[] = $indent . ' */';
            $s[] = $indent . 'var $auto_inc_col = '
                           . "'{$this->auto_inc_col[$table]}';\n";
        }
        $indent = substr($indent, 0, -4);
        $s[]    = $indent . '}';

        // Implode and return lines of class definition
        return implode("\n", $s) . "\n";

    }

    // }}}
    // {{{ function buildTableClasses()

    /**
     * Returns a string containing all table class definitions in one file
     *
     * The returned string contains the contents of a single php file with
     * definitions of DB_Table subclasses associated with all of the tables
     * in $this->tables. If $this->tables is initially null, method
     * $this->getTableNames() is called internally to generate a list of
     * table names.
     *
     * The returned string includes the opening and closing <?php and ?>
     * script elements, and the require_once line needed to include the
     * $this->extend_class (i.e., DB_Table or a subclass) that is being
     * extended. To use, write this string to a new php file.
     *
     * Usage:
     * <code>
     *     $generator = new DB_Table_Generator($db, $database);
     *     echo $generator->buildTablesClasses();
     * </code>
     *
     * @return mixed a string with all table class definitions,
     *                PEAR Error on failure
     * @access public
     */
    function buildTableClasses()
    {
        // If $this->tables is null, call getTableNames()
        if (!$this->tables) {
            $return = $this->getTableNames();
            if (PEAR::isError($return)) {
                return $return;
            }
        }

        $s   = array();
        $s[] = '<?php';
        $s[] = '/*';
        $s[] = ' * Include basic class';
        $s[] = ' */';
        $s[] = "require_once '{$this->extends_file}';\n";
        foreach ($this->tables as $table) {
            $return = $this->getTableDefinition($table);
            if (PEAR::isError($return)) {
                return $return;
            }
            $s[] = $this->buildTableClass($table) . "\n";
        }
        $s[] = '?>';
        return implode("\n", $s);
    }

    // }}}
    // {{{ function generateTableClassFiles()

    /**
     * Writes all table class definitions to separate files
     *
     * Usage:
     * <code>
     *     $generator = new DB_Table_Generator($db, $database);
     *     $generator->generateTableClassFiles();
     * </code>
     *
     * @return mixed true on success, PEAR Error on failure
     * @access public
     */
    function generateTableClassFiles()
    {
        // If $this->tables is null, call getTableNames()
        if (!$this->tables) {
            $return = $this->getTableNames();
            if (PEAR::isError($return)) {
                return $return;
            }
        }

        // Write all table class definitions to separate files
        foreach ($this->tables as $table) {
            $classname = $this->className($table);
            $filename  = $this->classFileName($classname);
            $base      = $this->class_write_path;
            if ($base) {
                if (!file_exists($base)) {
                    include_once 'System.php';
                    if (!@System::mkdir(array('-p', $base))) {
                        return $this->throwError(DB_TABLE_GENERATOR_ERR_FILE,
                            $base);
                    }

                }
                $filename = "{$base}/{$filename}";
            }
            if (!file_exists($filename)) {
                $s      = array();
                $s[]    = '<?php';
                $s[]    = '/*';
                $s[]    = ' * Include basic class';
                $s[]    = ' */';
                $s[]    = "require_once '{$this->extends_file}';\n";
                $return = $this->getTableDefinition($table);
                if (PEAR::isError($return)) {
                    return $return;
                }
                $s[] = $this->buildTableClass($table);
                $s[] = '?>';
                $s[] = '';
                $out = implode("\n", $s);
                if (!$file = @fopen($filename, 'wb')) {
                    return $this->throwError(DB_TABLE_GENERATOR_ERR_FILE,
                            $filename);
                }
                fputs($file, $out);
                fclose($file);
            }
        }

        return true;
    }

    // }}}
    // {{{ function generateDatabaseFile($object_name = null)

    /**
     * Writes a file to instantiate Table and Database objects
     *
     * After successful completion, a file named 'Database.php' will be
     * have been created in the $this->class_write_path directory. This
     * file should normally be included in application php scripts. It
     * can be renamed by the user.
     *
     * Usage:
     * <code>
     *     $generator = new DB_Table_Generator($db, $database);
     *     $generator->generateTableClassFiles();
     *     $generator->generateDatabaseFile();
     * </code>
     *
     * @param string $object_name variable name for DB_Table_Database object
     *
     * @return mixed true on success, PEAR Error on failure
     * @access public
     */
    function generateDatabaseFile($object_name = null)
    {
        // Set name for DB_Table_Database object
        if ($object_name) {
            $object_name = "\${$object_name}";
        } else {
            $object_name = '$db'; //default
        }
        $backend = strtoupper($this->backend); // 'DB' or 'MDB2'

        if ('DB' == $backend) {
            $dsn = $this->db->dsn;
        } else {
            $dsn = $this->db->getDSN('array');
        }

        // Create array d[] containing lines of database php file
        $d   = array();
        $d[] = '<?php';
        $d[] = '/*';
        $d[] = ' * Include basic classes';
        $d[] = ' */';
        $d[] = "require_once '{$backend}.php';";
        $d[] = "require_once 'DB/Table/Database.php';";

        // Require_once statements for subclass definitions
        foreach ($this->tables as $table) {
            $classname      = $this->className($table);
            $class_filename = $this->classFileName($classname);
            if ($this->class_include_path) {
                $d[] = 'require_once '
                     . "'{$this->class_include_path}/{$class_filename}';";
            } else {
                $d[] = "require_once '{$class_filename}';";
            }
        }
        $d[] = '';

        $d[] = '/*';
        $d[] = ' * NOTE: User must uncomment & edit code to create $dsn';
        $d[] = ' */';
        $d[] = "//\$phptype  = '{$dsn['phptype']}';";
        $d[] = "//\$username = '{$dsn['username']}';";
        $d[] = "//\$password = ''; // put your password here";
        $d[] = "//\$hostname = '{$dsn['hostspec']}';";
        $d[] = "//\$database = '{$dsn['database']}';";
        $d[] = "//\$create   = false; // 'drop', 'safe', 'verify', 'alter'";
        $d[] = '//$dsn      = "{$phptype}://{$username}:{$password}@{$hostname}'
             . '/{$database}";';
        $d[] = '';

        $d[] = '/*';
        $d[] = " * Instantiate {$backend} connection object \$conn";
        $d[] = ' */';
        $d[] = "\$conn =& {$backend}::connect(\$dsn);";
        $d[] = 'if (PEAR::isError($conn)) {';
        $d[] = '    echo "Error connecting to database server\n";';
        $d[] = '    echo $conn->getMessage();';
        $d[] = '    die;';
        $d[] = '}';
        $d[] = '';

        $d[] = '/*';
        $d[] = ' * Create one instance of each DB_Table subclass';
        $d[] = ' */';
        foreach ($this->tables as $table) {
            $classname = $this->className($table);

            $d[] = "\${$table} = new {$classname}("
                 . '$conn, ' . "'{$table}'" . ', $create);';
            $d[] = "if (PEAR::isError(\${$table}->error)) {";
            $d[] = '    echo "Can\'t create table object.\n";';
            $d[] = "    echo \${$table}->error->getMessage();";
            $d[] = '    die;';
            $d[] = '}';

        }
        $d[] = '';

        $d[] = '/*';
        $d[] = ' * Instantiate a parent DB_Table_Database object';
        $d[] = ' */';
        $d[] = "{$object_name} = new DB_Table_Database(\$conn, \$database);";
        $d[] = "if (PEAR::isError({$object_name}->error)) {";
        $d[] = '    echo "Can\'t create database object.\n";';
        $d[] = "    echo {$object_name}->error->getMessage();";
        $d[] = '    die;';
        $d[] = '}';
        $d[] = '';

        $d[] = '/*';
        $d[] = ' * Add DB_Table objects to parent DB_Table_Database object';
        $d[] = ' */';
        foreach ($this->tables as $table) {
            $classname = $this->className($table);

            $d[] = "\$result = {$object_name}->addTable(\${$table});";
            $d[] = 'if (PEAR::isError($result)) {';
            $d[] = '    echo "Can\'t add table object to database object.\n";';
            $d[] = '    echo $result->getMessage();';
            $d[] = '    die;';
            $d[] = '}';
        }
        $d[] = '';

        // Add foreign key references: If the name of an integer column
        // matches "/id$/i" (i.e., the names ends with id, ID, or Id), the
        // remainder of the name matches the name $rtable of another table,
        // and $rtable has an integer primary key, then the column is
        // assumed to be a foreign key that references $rtable.

        $d[] = '/*';
        $d[] = ' * Add auto-guessed foreign references';
        $d[] = ' */';
        foreach ($this->col as $table => $col) {
            foreach ($col as $col_name => $def) {

                // Only consider integer columns
                $ftype = $def['type'];
                if (!in_array($ftype, array('integer','smallint','bigint'))) {
                    continue;
                }
                if (preg_match("/id$/i", $col_name)) {
                    $column_base = preg_replace('/_?id$/i', '', $col_name);
                    foreach ($this->tables as $rtable) {
                        if (!preg_match("/^{$rtable}$/i", $column_base)) {
                            continue;
                        }
                        if (preg_match("/^{$table}$/i", $column_base)) {
                            continue;
                        }
                        if (!isset($this->primary_key[$rtable])) {
                            continue;
                        }
                        $rkey = $this->primary_key[$rtable];
                        if (is_array($rkey)) {
                            continue;
                        }
                        $rtype = $this->col[$rtable][$rkey]['type'];
                        if (!in_array($rtype,
                            array('integer','smallint','bigint'))) {
                            continue;
                        }
                        $d[] = "\$result = {$object_name}->addRef('{$table}', "
                             . "'{$col_name}', '{$rtable}');";
                        $d[] = 'if (PEAR::isError($result)) {';
                        $d[] = '    echo "Can\'t add foreign key reference.\n";';
                        $d[] = '    echo $result->getMessage();';
                        $d[] = '    die;';
                        $d[] = '}';
                    }
                }
            }
        }
        $d[] = '';
        $d[] = '/*';
        $d[] = ' * Add any additional foreign key references here';
        $d[] = ' *';
        $d[] = ' * Add any linking table declarations here';
        $d[] = ' * Uncomment next line to add all possible linking tables;';
        $d[] = ' */';
        $d[] = "//\$result = {$object_name}->addAllLinks();";
        $d[] = '//if (PEAR::isError($result)) {';
        $d[] = '//    echo "Can\'t add linking tables.\n";';
        $d[] = '//    echo $result->getMessage();';
        $d[] = '//    die;';
        $d[] = '//}';
        $d[] = '';

        // Closing script element
        $d[] = '?>';
        $d[] = '';

        // Open and write file
        $base = $this->class_write_path;
        if ($base) {
            if (!file_exists($base)) {
                include_once 'System.php';
                if (!@System::mkdir(array('-p', $base))) {
                    return $this->throwError(DB_TABLE_GENERATOR_ERR_FILE, $base);
                }
            }
            $filename = $base . '/Database.php';
        } else {
            $filename = 'Database.php';
        }
        if (!$file = @fopen($filename, 'wb')) {
            return $this->throwError(DB_TABLE_GENERATOR_ERR_FILE, $filename);
        }
        $out = implode("\n", $d);
        fputs($file, $out);
        fclose($file);

        return true;
    }

    // }}}
    // {{{ function className($table)

    /**
     * Convert a table name into a class name
     *
     * Converts all non-alphanumeric characters to '_', capitalizes
     * first letter, and adds $this->class_suffix to end. Override
     * this if you want something else.
     *
     * @param string $table name of table
     *
     * @return string class name;
     * @access public
     */
    function className($table)
    {
        $name = preg_replace('/[^A-Z0-9]/i', '_', ucfirst(trim($table)));
        return  $name . $this->class_suffix;
    }

    // }}}
    // {{{ function tableName($table)

    /**
     * Returns a valid variable name from a table name
     *
     * Converts all non-alphanumeric characters to '_'. Override
     * this if you want something else.
     *
     * @param string $table name of table
     *
     * @return string variable name;
     * @access public
     */
    function tableName($table)
    {
        return preg_replace('/[^A-Z0-9]/i', '_', trim($table));
    }

    // }}}
    // {{{ function classFileName($class_name)

    /**
     * Returns the path to a file containing a class definition
     *
     * Appends '.php' to class name.
     *
     * @param string $class_name name of class
     *
     * @return string file name
     * @access public
     */
    function classFileName($class_name)
    {
        $filename = $class_name . '.php';
        return $filename;
    }

    // }}}

}
// }}}