home *** CD-ROM | disk | FTP | other *** search
/ Cricao de Sites - 650 Layouts Prontos / WebMasters.iso / Servidores / xampp-win32-1.6.7-installer.exe / php / PEAR / adodb / adodb-datadict.inc.php < prev    next >
Encoding:
PHP Script  |  2008-02-13  |  26.6 KB  |  1,000 lines
  1. <?php
  2.  
  3. /**
  4.   V4.98 13 Feb 2008  (c) 2000-2008 John Lim (jlim#natsoft.com.my). All rights reserved.
  5.   Released under both BSD license and Lesser GPL library license. 
  6.   Whenever there is any discrepancy between the two licenses, 
  7.   the BSD license will take precedence.
  8.     
  9.   Set tabs to 4 for best viewing.
  10.  
  11.      DOCUMENTATION:
  12.     
  13.         See adodb/tests/test-datadict.php for docs and examples.
  14. */
  15.  
  16. /*
  17.     Test script for parser
  18. */
  19.  
  20. // security - hide paths
  21. if (!defined('ADODB_DIR')) die();
  22.  
  23. function Lens_ParseTest()
  24. {
  25. $str = "`zcol ACOL` NUMBER(32,2) DEFAULT 'The \"cow\" (and Jim''s dog) jumps over the moon' PRIMARY, INTI INT AUTO DEFAULT 0, zcol2\"afs ds";
  26. print "<p>$str</p>";
  27. $a= Lens_ParseArgs($str);
  28. print "<pre>";
  29. print_r($a);
  30. print "</pre>";
  31. }
  32.  
  33.  
  34. if (!function_exists('ctype_alnum')) {
  35.     function ctype_alnum($text) {
  36.         return preg_match('/^[a-z0-9]*$/i', $text);
  37.     }
  38. }
  39.  
  40. //Lens_ParseTest();
  41.  
  42. /**
  43.     Parse arguments, treat "text" (text) and 'text' as quotation marks.
  44.     To escape, use "" or '' or ))
  45.     
  46.     Will read in "abc def" sans quotes, as: abc def
  47.     Same with 'abc def'.
  48.     However if `abc def`, then will read in as `abc def`
  49.     
  50.     @param endstmtchar    Character that indicates end of statement
  51.     @param tokenchars     Include the following characters in tokens apart from A-Z and 0-9 
  52.     @returns 2 dimensional array containing parsed tokens.
  53. */
  54. function Lens_ParseArgs($args,$endstmtchar=',',$tokenchars='_.-')
  55. {
  56.     $pos = 0;
  57.     $intoken = false;
  58.     $stmtno = 0;
  59.     $endquote = false;
  60.     $tokens = array();
  61.     $tokens[$stmtno] = array();
  62.     $max = strlen($args);
  63.     $quoted = false;
  64.     $tokarr = array();
  65.     
  66.     while ($pos < $max) {
  67.         $ch = substr($args,$pos,1);
  68.         switch($ch) {
  69.         case ' ':
  70.         case "\t":
  71.         case "\n":
  72.         case "\r":
  73.             if (!$quoted) {
  74.                 if ($intoken) {
  75.                     $intoken = false;
  76.                     $tokens[$stmtno][] = implode('',$tokarr);
  77.                 }
  78.                 break;
  79.             }
  80.             
  81.             $tokarr[] = $ch;
  82.             break;
  83.         
  84.         case '`':
  85.             if ($intoken) $tokarr[] = $ch;
  86.         case '(':
  87.         case ')':    
  88.         case '"':
  89.         case "'":
  90.             
  91.             if ($intoken) {
  92.                 if (empty($endquote)) {
  93.                     $tokens[$stmtno][] = implode('',$tokarr);
  94.                     if ($ch == '(') $endquote = ')';
  95.                     else $endquote = $ch;
  96.                     $quoted = true;
  97.                     $intoken = true;
  98.                     $tokarr = array();
  99.                 } else if ($endquote == $ch) {
  100.                     $ch2 = substr($args,$pos+1,1);
  101.                     if ($ch2 == $endquote) {
  102.                         $pos += 1;
  103.                         $tokarr[] = $ch2;
  104.                     } else {
  105.                         $quoted = false;
  106.                         $intoken = false;
  107.                         $tokens[$stmtno][] = implode('',$tokarr);
  108.                         $endquote = '';
  109.                     }
  110.                 } else
  111.                     $tokarr[] = $ch;
  112.                     
  113.             }else {
  114.             
  115.                 if ($ch == '(') $endquote = ')';
  116.                 else $endquote = $ch;
  117.                 $quoted = true;
  118.                 $intoken = true;
  119.                 $tokarr = array();
  120.                 if ($ch == '`') $tokarr[] = '`';
  121.             }
  122.             break;
  123.             
  124.         default:
  125.             
  126.             if (!$intoken) {
  127.                 if ($ch == $endstmtchar) {
  128.                     $stmtno += 1;
  129.                     $tokens[$stmtno] = array();
  130.                     break;
  131.                 }
  132.             
  133.                 $intoken = true;
  134.                 $quoted = false;
  135.                 $endquote = false;
  136.                 $tokarr = array();
  137.     
  138.             }
  139.             
  140.             if ($quoted) $tokarr[] = $ch;
  141.             else if (ctype_alnum($ch) || strpos($tokenchars,$ch) !== false) $tokarr[] = $ch;
  142.             else {
  143.                 if ($ch == $endstmtchar) {            
  144.                     $tokens[$stmtno][] = implode('',$tokarr);
  145.                     $stmtno += 1;
  146.                     $tokens[$stmtno] = array();
  147.                     $intoken = false;
  148.                     $tokarr = array();
  149.                     break;
  150.                 }
  151.                 $tokens[$stmtno][] = implode('',$tokarr);
  152.                 $tokens[$stmtno][] = $ch;
  153.                 $intoken = false;
  154.             }
  155.         }
  156.         $pos += 1;
  157.     }
  158.     if ($intoken) $tokens[$stmtno][] = implode('',$tokarr);
  159.     
  160.     return $tokens;
  161. }
  162.  
  163.  
  164. class ADODB_DataDict {
  165.     var $connection;
  166.     var $debug = false;
  167.     var $dropTable = 'DROP TABLE %s';
  168.     var $renameTable = 'RENAME TABLE %s TO %s'; 
  169.     var $dropIndex = 'DROP INDEX %s';
  170.     var $addCol = ' ADD';
  171.     var $alterCol = ' ALTER COLUMN';
  172.     var $dropCol = ' DROP COLUMN';
  173.     var $renameColumn = 'ALTER TABLE %s RENAME COLUMN %s TO %s';    // table, old-column, new-column, column-definitions (not used by default)
  174.     var $nameRegex = '\w';
  175.     var $nameRegexBrackets = 'a-zA-Z0-9_\(\)';
  176.     var $schema = false;
  177.     var $serverInfo = array();
  178.     var $autoIncrement = false;
  179.     var $dataProvider;
  180.     var $invalidResizeTypes4 = array('CLOB','BLOB','TEXT','DATE','TIME'); // for changetablesql
  181.     var $blobSize = 100;     /// any varchar/char field this size or greater is treated as a blob
  182.                             /// in other words, we use a text area for editting.
  183.     
  184.     function GetCommentSQL($table,$col)
  185.     {
  186.         return false;
  187.     }
  188.     
  189.     function SetCommentSQL($table,$col,$cmt)
  190.     {
  191.         return false;
  192.     }
  193.     
  194.     function MetaTables()
  195.     {
  196.         if (!$this->connection->IsConnected()) return array();
  197.         return $this->connection->MetaTables();
  198.     }
  199.     
  200.     function MetaColumns($tab, $upper=true, $schema=false)
  201.     {
  202.         if (!$this->connection->IsConnected()) return array();
  203.         return $this->connection->MetaColumns($this->TableName($tab), $upper, $schema);
  204.     }
  205.     
  206.     function MetaPrimaryKeys($tab,$owner=false,$intkey=false)
  207.     {
  208.         if (!$this->connection->IsConnected()) return array();
  209.         return $this->connection->MetaPrimaryKeys($this->TableName($tab), $owner, $intkey);
  210.     }
  211.     
  212.     function MetaIndexes($table, $primary = false, $owner = false)
  213.     {
  214.         if (!$this->connection->IsConnected()) return array();
  215.         return $this->connection->MetaIndexes($this->TableName($table), $primary, $owner);
  216.     }
  217.     
  218.  
  219.     function MetaType($t,$len=-1,$fieldobj=false)
  220.     {        
  221.         static $typeMap = array(
  222.         'VARCHAR' => 'C',
  223.         'VARCHAR2' => 'C',
  224.         'CHAR' => 'C',
  225.         'C' => 'C',
  226.         'STRING' => 'C',
  227.         'NCHAR' => 'C',
  228.         'NVARCHAR' => 'C',
  229.         'VARYING' => 'C',
  230.         'BPCHAR' => 'C',
  231.         'CHARACTER' => 'C',
  232.         'INTERVAL' => 'C',  # Postgres
  233.         'MACADDR' => 'C', # postgres
  234.         ##
  235.         'LONGCHAR' => 'X',
  236.         'TEXT' => 'X',
  237.         'NTEXT' => 'X',
  238.         'M' => 'X',
  239.         'X' => 'X',
  240.         'CLOB' => 'X',
  241.         'NCLOB' => 'X',
  242.         'LVARCHAR' => 'X',
  243.         ##
  244.         'BLOB' => 'B',
  245.         'IMAGE' => 'B',
  246.         'BINARY' => 'B',
  247.         'VARBINARY' => 'B',
  248.         'LONGBINARY' => 'B',
  249.         'B' => 'B',
  250.         ##
  251.         'YEAR' => 'D', // mysql
  252.         'DATE' => 'D',
  253.         'D' => 'D',
  254.         ##
  255.         'UNIQUEIDENTIFIER' => 'C', # MS SQL Server
  256.         ##
  257.         'TIME' => 'T',
  258.         'TIMESTAMP' => 'T',
  259.         'DATETIME' => 'T',
  260.         'TIMESTAMPTZ' => 'T',
  261.         'T' => 'T',
  262.         'TIMESTAMP WITHOUT TIME ZONE' => 'T', // postgresql
  263.         ##
  264.         'BOOL' => 'L',
  265.         'BOOLEAN' => 'L', 
  266.         'BIT' => 'L',
  267.         'L' => 'L',
  268.         ##
  269.         'COUNTER' => 'R',
  270.         'R' => 'R',
  271.         'SERIAL' => 'R', // ifx
  272.         'INT IDENTITY' => 'R',
  273.         ##
  274.         'INT' => 'I',
  275.         'INT2' => 'I',
  276.         'INT4' => 'I',
  277.         'INT8' => 'I',
  278.         'INTEGER' => 'I',
  279.         'INTEGER UNSIGNED' => 'I',
  280.         'SHORT' => 'I',
  281.         'TINYINT' => 'I',
  282.         'SMALLINT' => 'I',
  283.         'I' => 'I',
  284.         ##
  285.         'LONG' => 'N', // interbase is numeric, oci8 is blob
  286.         'BIGINT' => 'N', // this is bigger than PHP 32-bit integers
  287.         'DECIMAL' => 'N',
  288.         'DEC' => 'N',
  289.         'REAL' => 'N',
  290.         'DOUBLE' => 'N',
  291.         'DOUBLE PRECISION' => 'N',
  292.         'SMALLFLOAT' => 'N',
  293.         'FLOAT' => 'N',
  294.         'NUMBER' => 'N',
  295.         'NUM' => 'N',
  296.         'NUMERIC' => 'N',
  297.         'MONEY' => 'N',
  298.         
  299.         ## informix 9.2
  300.         'SQLINT' => 'I', 
  301.         'SQLSERIAL' => 'I', 
  302.         'SQLSMINT' => 'I', 
  303.         'SQLSMFLOAT' => 'N', 
  304.         'SQLFLOAT' => 'N', 
  305.         'SQLMONEY' => 'N', 
  306.         'SQLDECIMAL' => 'N', 
  307.         'SQLDATE' => 'D', 
  308.         'SQLVCHAR' => 'C', 
  309.         'SQLCHAR' => 'C', 
  310.         'SQLDTIME' => 'T', 
  311.         'SQLINTERVAL' => 'N', 
  312.         'SQLBYTES' => 'B', 
  313.         'SQLTEXT' => 'X',
  314.          ## informix 10
  315.         "SQLINT8" => 'I8',
  316.         "SQLSERIAL8" => 'I8',
  317.         "SQLNCHAR" => 'C',
  318.         "SQLNVCHAR" => 'C',
  319.         "SQLLVARCHAR" => 'X',
  320.         "SQLBOOL" => 'L'
  321.         );
  322.         
  323.         if (!$this->connection->IsConnected()) {
  324.             $t = strtoupper($t);
  325.             if (isset($typeMap[$t])) return $typeMap[$t];
  326.             return 'N';
  327.         }
  328.         return $this->connection->MetaType($t,$len,$fieldobj);
  329.     }
  330.     
  331.     function NameQuote($name = NULL,$allowBrackets=false)
  332.     {
  333.         if (!is_string($name)) {
  334.             return FALSE;
  335.         }
  336.         
  337.         $name = trim($name);
  338.         
  339.         if ( !is_object($this->connection) ) {
  340.             return $name;
  341.         }
  342.         
  343.         $quote = $this->connection->nameQuote;
  344.         
  345.         // if name is of the form `name`, quote it
  346.         if ( preg_match('/^`(.+)`$/', $name, $matches) ) {
  347.             return $quote . $matches[1] . $quote;
  348.         }
  349.         
  350.         // if name contains special characters, quote it
  351.         $regex = ($allowBrackets) ? $this->nameRegexBrackets : $this->nameRegex;
  352.         
  353.         if ( !preg_match('/^[' . $regex . ']+$/', $name) ) {
  354.             return $quote . $name . $quote;
  355.         }
  356.         
  357.         return $name;
  358.     }
  359.     
  360.     function TableName($name)
  361.     {
  362.         if ( $this->schema ) {
  363.             return $this->NameQuote($this->schema) .'.'. $this->NameQuote($name);
  364.         }
  365.         return $this->NameQuote($name);
  366.     }
  367.     
  368.     // Executes the sql array returned by GetTableSQL and GetIndexSQL
  369.     function ExecuteSQLArray($sql, $continueOnError = true)
  370.     {
  371.         $rez = 2;
  372.         $conn = &$this->connection;
  373.         $saved = $conn->debug;
  374.         foreach($sql as $line) {
  375.             
  376.             if ($this->debug) $conn->debug = true;
  377.             $ok = $conn->Execute($line);
  378.             $conn->debug = $saved;
  379.             if (!$ok) {
  380.                 if ($this->debug) ADOConnection::outp($conn->ErrorMsg());
  381.                 if (!$continueOnError) return 0;
  382.                 $rez = 1;
  383.             }
  384.         }
  385.         return $rez;
  386.     }
  387.     
  388.     /**
  389.          Returns the actual type given a character code.
  390.         
  391.         C:  varchar
  392.         X:  CLOB (character large object) or largest varchar size if CLOB is not supported
  393.         C2: Multibyte varchar
  394.         X2: Multibyte CLOB
  395.         
  396.         B:  BLOB (binary large object)
  397.         
  398.         D:  Date
  399.         T:  Date-time 
  400.         L:  Integer field suitable for storing booleans (0 or 1)
  401.         I:  Integer
  402.         F:  Floating point number
  403.         N:  Numeric or decimal number
  404.     */
  405.     
  406.     function ActualType($meta)
  407.     {
  408.         return $meta;
  409.     }
  410.     
  411.     function CreateDatabase($dbname,$options=false)
  412.     {
  413.         $options = $this->_Options($options);
  414.         $sql = array();
  415.         
  416.         $s = 'CREATE DATABASE ' . $this->NameQuote($dbname);
  417.         if (isset($options[$this->upperName]))
  418.             $s .= ' '.$options[$this->upperName];
  419.         
  420.         $sql[] = $s;
  421.         return $sql;
  422.     }
  423.     
  424.     /*
  425.      Generates the SQL to create index. Returns an array of sql strings.
  426.     */
  427.     function CreateIndexSQL($idxname, $tabname, $flds, $idxoptions = false)
  428.     {
  429.         if (!is_array($flds)) {
  430.             $flds = explode(',',$flds);
  431.         }
  432.         
  433.         foreach($flds as $key => $fld) {
  434.             # some indexes can use partial fields, eg. index first 32 chars of "name" with NAME(32)
  435.             $flds[$key] = $this->NameQuote($fld,$allowBrackets=true);
  436.         }
  437.         
  438.         return $this->_IndexSQL($this->NameQuote($idxname), $this->TableName($tabname), $flds, $this->_Options($idxoptions));
  439.     }
  440.     
  441.     function DropIndexSQL ($idxname, $tabname = NULL)
  442.     {
  443.         return array(sprintf($this->dropIndex, $this->NameQuote($idxname), $this->TableName($tabname)));
  444.     }
  445.     
  446.     function SetSchema($schema)
  447.     {
  448.         $this->schema = $schema;
  449.     }
  450.     
  451.     function AddColumnSQL($tabname, $flds)
  452.     {
  453.         $tabname = $this->TableName ($tabname);
  454.         $sql = array();
  455.         list($lines,$pkey,$idxs) = $this->_GenFields($flds);
  456.         // genfields can return FALSE at times
  457.         if ($lines  == null) $lines = array();
  458.         $alter = 'ALTER TABLE ' . $tabname . $this->addCol . ' ';
  459.         foreach($lines as $v) {
  460.             $sql[] = $alter . $v;
  461.         }
  462.         if (is_array($idxs)) {
  463.             foreach($idxs as $idx => $idxdef) {
  464.                 $sql_idxs = $this->CreateIndexSql($idx, $tabname, $idxdef['cols'], $idxdef['opts']);
  465.                 $sql = array_merge($sql, $sql_idxs);
  466.             }
  467.         }
  468.         return $sql;
  469.     }
  470.     
  471.     /**
  472.      * Change the definition of one column
  473.      *
  474.      * As some DBM's can't do that on there own, you need to supply the complete defintion of the new table,
  475.      * to allow, recreating the table and copying the content over to the new table
  476.      * @param string $tabname table-name
  477.      * @param string $flds column-name and type for the changed column
  478.      * @param string $tableflds='' complete defintion of the new table, eg. for postgres, default ''
  479.      * @param array/string $tableoptions='' options for the new table see CreateTableSQL, default ''
  480.      * @return array with SQL strings
  481.      */
  482.     function AlterColumnSQL($tabname, $flds, $tableflds='',$tableoptions='')
  483.     {
  484.         $tabname = $this->TableName ($tabname);
  485.         $sql = array();
  486.         list($lines,$pkey,$idxs) = $this->_GenFields($flds);
  487.         // genfields can return FALSE at times
  488.         if ($lines == null) $lines = array();
  489.         $alter = 'ALTER TABLE ' . $tabname . $this->alterCol . ' ';
  490.         foreach($lines as $v) {
  491.             $sql[] = $alter . $v;
  492.         }
  493.         if (is_array($idxs)) {
  494.             foreach($idxs as $idx => $idxdef) {
  495.                 $sql_idxs = $this->CreateIndexSql($idx, $tabname, $idxdef['cols'], $idxdef['opts']);
  496.                 $sql = array_merge($sql, $sql_idxs);
  497.             }
  498.  
  499.         }
  500.         return $sql;
  501.     }
  502.     
  503.     /**
  504.      * Rename one column
  505.      *
  506.      * Some DBM's can only do this together with changeing the type of the column (even if that stays the same, eg. mysql)
  507.      * @param string $tabname table-name
  508.      * @param string $oldcolumn column-name to be renamed
  509.      * @param string $newcolumn new column-name
  510.      * @param string $flds='' complete column-defintion-string like for AddColumnSQL, only used by mysql atm., default=''
  511.      * @return array with SQL strings
  512.      */
  513.     function RenameColumnSQL($tabname,$oldcolumn,$newcolumn,$flds='')
  514.     {
  515.         $tabname = $this->TableName ($tabname);
  516.         if ($flds) {
  517.             list($lines,$pkey,$idxs) = $this->_GenFields($flds);
  518.             // genfields can return FALSE at times
  519.             if ($lines == null) $lines = array();
  520.             list(,$first) = each($lines);
  521.             list(,$column_def) = split("[\t ]+",$first,2);
  522.         }
  523.         return array(sprintf($this->renameColumn,$tabname,$this->NameQuote($oldcolumn),$this->NameQuote($newcolumn),$column_def));
  524.     }
  525.         
  526.     /**
  527.      * Drop one column
  528.      *
  529.      * Some DBM's can't do that on there own, you need to supply the complete defintion of the new table,
  530.      * to allow, recreating the table and copying the content over to the new table
  531.      * @param string $tabname table-name
  532.      * @param string $flds column-name and type for the changed column
  533.      * @param string $tableflds='' complete defintion of the new table, eg. for postgres, default ''
  534.      * @param array/string $tableoptions='' options for the new table see CreateTableSQL, default ''
  535.      * @return array with SQL strings
  536.      */
  537.     function DropColumnSQL($tabname, $flds, $tableflds='',$tableoptions='')
  538.     {
  539.         $tabname = $this->TableName ($tabname);
  540.         if (!is_array($flds)) $flds = explode(',',$flds);
  541.         $sql = array();
  542.         $alter = 'ALTER TABLE ' . $tabname . $this->dropCol . ' ';
  543.         foreach($flds as $v) {
  544.             $sql[] = $alter . $this->NameQuote($v);
  545.         }
  546.         return $sql;
  547.     }
  548.     
  549.     function DropTableSQL($tabname)
  550.     {
  551.         return array (sprintf($this->dropTable, $this->TableName($tabname)));
  552.     }
  553.     
  554.     function RenameTableSQL($tabname,$newname)
  555.     {
  556.         return array (sprintf($this->renameTable, $this->TableName($tabname),$this->TableName($newname)));
  557.     }    
  558.     
  559.     /**
  560.      Generate the SQL to create table. Returns an array of sql strings.
  561.     */
  562.     function CreateTableSQL($tabname, $flds, $tableoptions=array())
  563.     {
  564.         list($lines,$pkey,$idxs) = $this->_GenFields($flds, true);
  565.         // genfields can return FALSE at times
  566.         if ($lines == null) $lines = array();
  567.         
  568.         $taboptions = $this->_Options($tableoptions);
  569.         $tabname = $this->TableName ($tabname);
  570.         $sql = $this->_TableSQL($tabname,$lines,$pkey,$taboptions);
  571.         
  572.         // ggiunta - 2006/10/12 - KLUDGE:
  573.         // if we are on autoincrement, and table options includes REPLACE, the
  574.         // autoincrement sequence has already been dropped on table creation sql, so
  575.         // we avoid passing REPLACE to trigger creation code. This prevents
  576.         // creating sql that double-drops the sequence
  577.         if ($this->autoIncrement && isset($taboptions['REPLACE']))
  578.             unset($taboptions['REPLACE']);
  579.         $tsql = $this->_Triggers($tabname,$taboptions);
  580.         foreach($tsql as $s) $sql[] = $s;
  581.         
  582.         if (is_array($idxs)) {
  583.             foreach($idxs as $idx => $idxdef) {
  584.                 $sql_idxs = $this->CreateIndexSql($idx, $tabname,  $idxdef['cols'], $idxdef['opts']);
  585.                 $sql = array_merge($sql, $sql_idxs);
  586.             }
  587.         }
  588.  
  589.         return $sql;
  590.     }
  591.     
  592.     function _GenFields($flds,$widespacing=false)
  593.     {
  594.         if (is_string($flds)) {
  595.             $padding = '     ';
  596.             $txt = $flds.$padding;
  597.             $flds = array();
  598.             $flds0 = Lens_ParseArgs($txt,',');
  599.             $hasparam = false;
  600.             foreach($flds0 as $f0) {
  601.                 $f1 = array();
  602.                 foreach($f0 as $token) {
  603.                     switch (strtoupper($token)) {
  604.                     case 'INDEX':
  605.                         $f1['INDEX'] = '';
  606.                         // fall through intentionally
  607.                     case 'CONSTRAINT':
  608.                     case 'DEFAULT': 
  609.                         $hasparam = $token;
  610.                         break;
  611.                     default:
  612.                         if ($hasparam) $f1[$hasparam] = $token;
  613.                         else $f1[] = $token;
  614.                         $hasparam = false;
  615.                         break;
  616.                     }
  617.                 }
  618.                 // 'index' token without a name means single column index: name it after column
  619.                 if (array_key_exists('INDEX', $f1) && $f1['INDEX'] == '') {
  620.                     $f1['INDEX'] = isset($f0['NAME']) ? $f0['NAME'] : $f0[0];
  621.                     // check if column name used to create an index name was quoted
  622.                     if (($f1['INDEX'][0] == '"' || $f1['INDEX'][0] == "'" || $f1['INDEX'][0] == "`") &&
  623.                         ($f1['INDEX'][0] == substr($f1['INDEX'], -1))) {
  624.                         $f1['INDEX'] = $f1['INDEX'][0].'idx_'.substr($f1['INDEX'], 1, -1).$f1['INDEX'][0];
  625.                     }
  626.                     else
  627.                         $f1['INDEX'] = 'idx_'.$f1['INDEX'];
  628.                 }
  629.                 // reset it, so we don't get next field 1st token as INDEX...
  630.                 $hasparam = false;
  631.  
  632.                 $flds[] = $f1;
  633.                 
  634.             }
  635.         }
  636.         $this->autoIncrement = false;
  637.         $lines = array();
  638.         $pkey = array();
  639.         $idxs = array();
  640.         foreach($flds as $fld) {
  641.             $fld = _array_change_key_case($fld);
  642.             
  643.             $fname = false;
  644.             $fdefault = false;
  645.             $fautoinc = false;
  646.             $ftype = false;
  647.             $fsize = false;
  648.             $fprec = false;
  649.             $fprimary = false;
  650.             $fnoquote = false;
  651.             $fdefts = false;
  652.             $fdefdate = false;
  653.             $fconstraint = false;
  654.             $fnotnull = false;
  655.             $funsigned = false;
  656.             $findex = '';
  657.             $funiqueindex = false;
  658.             
  659.             //-----------------
  660.             // Parse attributes
  661.             foreach($fld as $attr => $v) {
  662.                 if ($attr == 2 && is_numeric($v)) $attr = 'SIZE';
  663.                 else if (is_numeric($attr) && $attr > 1 && !is_numeric($v)) $attr = strtoupper($v);
  664.                 
  665.                 switch($attr) {
  666.                 case '0':
  667.                 case 'NAME':     $fname = $v; break;
  668.                 case '1':
  669.                 case 'TYPE':     $ty = $v; $ftype = $this->ActualType(strtoupper($v)); break;
  670.                 
  671.                 case 'SIZE':     
  672.                                 $dotat = strpos($v,'.'); if ($dotat === false) $dotat = strpos($v,',');
  673.                                 if ($dotat === false) $fsize = $v;
  674.                                 else {
  675.                                     $fsize = substr($v,0,$dotat);
  676.                                     $fprec = substr($v,$dotat+1);
  677.                                 }
  678.                                 break;
  679.                 case 'UNSIGNED': $funsigned = true; break;
  680.                 case 'AUTOINCREMENT':
  681.                 case 'AUTO':    $fautoinc = true; $fnotnull = true; break;
  682.                 case 'KEY':
  683.                 // a primary key col can be non unique in itself (if key spans many cols...)
  684.                 case 'PRIMARY':    $fprimary = $v; $fnotnull = true; /*$funiqueindex = true;*/ break;
  685.                 case 'DEF':
  686.                 case 'DEFAULT': $fdefault = $v; break;
  687.                 case 'NOTNULL': $fnotnull = $v; break;
  688.                 case 'NOQUOTE': $fnoquote = $v; break;
  689.                 case 'DEFDATE': $fdefdate = $v; break;
  690.                 case 'DEFTIMESTAMP': $fdefts = $v; break;
  691.                 case 'CONSTRAINT': $fconstraint = $v; break;
  692.                 // let INDEX keyword create a 'very standard' index on column
  693.                 case 'INDEX': $findex = $v; break;
  694.                 case 'UNIQUE': $funiqueindex = true; break;
  695.                 } //switch
  696.             } // foreach $fld
  697.             
  698.             //--------------------
  699.             // VALIDATE FIELD INFO
  700.             if (!strlen($fname)) {
  701.                 if ($this->debug) ADOConnection::outp("Undefined NAME");
  702.                 return false;
  703.             }
  704.             
  705.             $fid = strtoupper(preg_replace('/^`(.+)`$/', '$1', $fname));
  706.             $fname = $this->NameQuote($fname);
  707.             
  708.             if (!strlen($ftype)) {
  709.                 if ($this->debug) ADOConnection::outp("Undefined TYPE for field '$fname'");
  710.                 return false;
  711.             } else {
  712.                 $ftype = strtoupper($ftype);
  713.             }
  714.             
  715.             $ftype = $this->_GetSize($ftype, $ty, $fsize, $fprec);
  716.             
  717.             if ($ty == 'X' || $ty == 'X2' || $ty == 'B') $fnotnull = false; // some blob types do not accept nulls
  718.             
  719.             if ($fprimary) $pkey[] = $fname;
  720.             
  721.             // some databases do not allow blobs to have defaults
  722.             if ($ty == 'X') $fdefault = false;
  723.             
  724.             // build list of indexes
  725.             if ($findex != '') {
  726.                 if (array_key_exists($findex, $idxs)) {
  727.                     $idxs[$findex]['cols'][] = ($fname);
  728.                     if (in_array('UNIQUE', $idxs[$findex]['opts']) != $funiqueindex) {
  729.                         if ($this->debug) ADOConnection::outp("Index $findex defined once UNIQUE and once not");
  730.                     }
  731.                     if ($funiqueindex && !in_array('UNIQUE', $idxs[$findex]['opts']))
  732.                         $idxs[$findex]['opts'][] = 'UNIQUE';
  733.                 }
  734.                 else
  735.                 {
  736.                     $idxs[$findex] = array();
  737.                     $idxs[$findex]['cols'] = array($fname);
  738.                     if ($funiqueindex)
  739.                         $idxs[$findex]['opts'] = array('UNIQUE');
  740.                     else
  741.                         $idxs[$findex]['opts'] = array();
  742.                 }
  743.             }
  744.  
  745.             //--------------------
  746.             // CONSTRUCT FIELD SQL
  747.             if ($fdefts) {
  748.                 if (substr($this->connection->databaseType,0,5) == 'mysql') {
  749.                     $ftype = 'TIMESTAMP';
  750.                 } else {
  751.                     $fdefault = $this->connection->sysTimeStamp;
  752.                 }
  753.             } else if ($fdefdate) {
  754.                 if (substr($this->connection->databaseType,0,5) == 'mysql') {
  755.                     $ftype = 'TIMESTAMP';
  756.                 } else {
  757.                     $fdefault = $this->connection->sysDate;
  758.                 }
  759.             } else if ($fdefault !== false && !$fnoquote) {
  760.                 if ($ty == 'C' or $ty == 'X' or 
  761.                     ( substr($fdefault,0,1) != "'" && !is_numeric($fdefault))) {
  762.  
  763.                     if (($ty == 'D' || $ty == 'T') && strtolower($fdefault) != 'null') {
  764.                         // convert default date into database-aware code
  765.                         if ($ty == 'T')
  766.                         {
  767.                             $fdefault = $this->connection->DBTimeStamp($fdefault);
  768.                         }
  769.                         else
  770.                         {
  771.                             $fdefault = $this->connection->DBDate($fdefault);
  772.                         }
  773.                     }
  774.                     else
  775.                     if (strlen($fdefault) != 1 && substr($fdefault,0,1) == ' ' && substr($fdefault,strlen($fdefault)-1) == ' ') 
  776.                         $fdefault = trim($fdefault);
  777.                     else if (strtolower($fdefault) != 'null')
  778.                         $fdefault = $this->connection->qstr($fdefault);
  779.                 }
  780.             }
  781.             $suffix = $this->_CreateSuffix($fname,$ftype,$fnotnull,$fdefault,$fautoinc,$fconstraint,$funsigned);
  782.             
  783.             // add index creation
  784.             if ($widespacing) $fname = str_pad($fname,24);
  785.             
  786.              // check for field names appearing twice
  787.             if (array_key_exists($fid, $lines)) {
  788.                  ADOConnection::outp("Field '$fname' defined twice");
  789.             }
  790.             
  791.             $lines[$fid] = $fname.' '.$ftype.$suffix;
  792.             
  793.             if ($fautoinc) $this->autoIncrement = true;
  794.         } // foreach $flds
  795.         
  796.         return array($lines,$pkey,$idxs);
  797.     }
  798.  
  799.     /**
  800.          GENERATE THE SIZE PART OF THE DATATYPE
  801.             $ftype is the actual type
  802.             $ty is the type defined originally in the DDL
  803.     */
  804.     function _GetSize($ftype, $ty, $fsize, $fprec)
  805.     {
  806.         if (strlen($fsize) && $ty != 'X' && $ty != 'B' && strpos($ftype,'(') === false) {
  807.             $ftype .= "(".$fsize;
  808.             if (strlen($fprec)) $ftype .= ",".$fprec;
  809.             $ftype .= ')';
  810.         }
  811.         return $ftype;
  812.     }
  813.     
  814.     
  815.     // return string must begin with space
  816.     function _CreateSuffix($fname,$ftype,$fnotnull,$fdefault,$fautoinc,$fconstraint)
  817.     {    
  818.         $suffix = '';
  819.         if (strlen($fdefault)) $suffix .= " DEFAULT $fdefault";
  820.         if ($fnotnull) $suffix .= ' NOT NULL';
  821.         if ($fconstraint) $suffix .= ' '.$fconstraint;
  822.         return $suffix;
  823.     }
  824.     
  825.     function _IndexSQL($idxname, $tabname, $flds, $idxoptions)
  826.     {
  827.         $sql = array();
  828.         
  829.         if ( isset($idxoptions['REPLACE']) || isset($idxoptions['DROP']) ) {
  830.             $sql[] = sprintf ($this->dropIndex, $idxname);
  831.             if ( isset($idxoptions['DROP']) )
  832.                 return $sql;
  833.         }
  834.         
  835.         if ( empty ($flds) ) {
  836.             return $sql;
  837.         }
  838.         
  839.         $unique = isset($idxoptions['UNIQUE']) ? ' UNIQUE' : '';
  840.     
  841.         $s = 'CREATE' . $unique . ' INDEX ' . $idxname . ' ON ' . $tabname . ' ';
  842.         
  843.         if ( isset($idxoptions[$this->upperName]) )
  844.             $s .= $idxoptions[$this->upperName];
  845.         
  846.         if ( is_array($flds) )
  847.             $flds = implode(', ',$flds);
  848.         $s .= '(' . $flds . ')';
  849.         $sql[] = $s;
  850.         
  851.         return $sql;
  852.     }
  853.     
  854.     function _DropAutoIncrement($tabname)
  855.     {
  856.         return false;
  857.     }
  858.     
  859.     function _TableSQL($tabname,$lines,$pkey,$tableoptions)
  860.     {
  861.         $sql = array();
  862.         
  863.         if (isset($tableoptions['REPLACE']) || isset ($tableoptions['DROP'])) {
  864.             $sql[] = sprintf($this->dropTable,$tabname);
  865.             if ($this->autoIncrement) {
  866.                 $sInc = $this->_DropAutoIncrement($tabname);
  867.                 if ($sInc) $sql[] = $sInc;
  868.             }
  869.             if ( isset ($tableoptions['DROP']) ) {
  870.                 return $sql;
  871.             }
  872.         }
  873.         $s = "CREATE TABLE $tabname (\n";
  874.         $s .= implode(",\n", $lines);
  875.         if (sizeof($pkey)>0) {
  876.             $s .= ",\n                 PRIMARY KEY (";
  877.             $s .= implode(", ",$pkey).")";
  878.         }
  879.         if (isset($tableoptions['CONSTRAINTS'])) 
  880.             $s .= "\n".$tableoptions['CONSTRAINTS'];
  881.         
  882.         if (isset($tableoptions[$this->upperName.'_CONSTRAINTS'])) 
  883.             $s .= "\n".$tableoptions[$this->upperName.'_CONSTRAINTS'];
  884.         
  885.         $s .= "\n)";
  886.         if (isset($tableoptions[$this->upperName])) $s .= $tableoptions[$this->upperName];
  887.         $sql[] = $s;
  888.         
  889.         return $sql;
  890.     }
  891.     
  892.     /**
  893.         GENERATE TRIGGERS IF NEEDED
  894.         used when table has auto-incrementing field that is emulated using triggers
  895.     */
  896.     function _Triggers($tabname,$taboptions)
  897.     {
  898.         return array();
  899.     }
  900.     
  901.     /**
  902.         Sanitize options, so that array elements with no keys are promoted to keys
  903.     */
  904.     function _Options($opts)
  905.     {
  906.         if (!is_array($opts)) return array();
  907.         $newopts = array();
  908.         foreach($opts as $k => $v) {
  909.             if (is_numeric($k)) $newopts[strtoupper($v)] = $v;
  910.             else $newopts[strtoupper($k)] = $v;
  911.         }
  912.         return $newopts;
  913.     }
  914.     
  915.     /**
  916.     "Florian Buzin [ easywe ]" <florian.buzin#easywe.de>
  917.     
  918.     This function changes/adds new fields to your table. You don't
  919.     have to know if the col is new or not. It will check on its own.
  920.     */
  921.     function ChangeTableSQL($tablename, $flds, $tableoptions = false)
  922.     {
  923.     global $ADODB_FETCH_MODE;
  924.     
  925.         $save = $ADODB_FETCH_MODE;
  926.         $ADODB_FETCH_MODE = ADODB_FETCH_ASSOC;
  927.         if ($this->connection->fetchMode !== false) $savem = $this->connection->SetFetchMode(false);
  928.         
  929.         // check table exists
  930.         $save_handler = $this->connection->raiseErrorFn;
  931.         $this->connection->raiseErrorFn = '';
  932.         $cols = $this->MetaColumns($tablename);
  933.         $this->connection->raiseErrorFn = $save_handler;
  934.         
  935.         if (isset($savem)) $this->connection->SetFetchMode($savem);
  936.         $ADODB_FETCH_MODE = $save;
  937.         
  938.         if ( empty($cols)) { 
  939.             return $this->CreateTableSQL($tablename, $flds, $tableoptions);
  940.         }
  941.         
  942.         if (is_array($flds)) {
  943.         // Cycle through the update fields, comparing
  944.         // existing fields to fields to update.
  945.         // if the Metatype and size is exactly the
  946.         // same, ignore - by Mark Newham
  947.             $holdflds = array();
  948.             foreach($flds as $k=>$v) {
  949.                 if ( isset($cols[$k]) && is_object($cols[$k]) ) {
  950.                     // If already not allowing nulls, then don't change
  951.                     $obj = $cols[$k];
  952.                     if (isset($obj->not_null) && $obj->not_null)
  953.                         $v = str_replace('NOT NULL','',$v);
  954.  
  955.                     $c = $cols[$k];
  956.                     $ml = $c->max_length;
  957.                     $mt = $this->MetaType($c->type,$ml);
  958.                     if ($ml == -1) $ml = '';
  959.                     if ($mt == 'X') $ml = $v['SIZE'];
  960.                     if (($mt != $v['TYPE']) ||  $ml != $v['SIZE']) {
  961.                         $holdflds[$k] = $v;
  962.                     }
  963.                 } else {
  964.                     $holdflds[$k] = $v;
  965.                 }        
  966.             }
  967.             $flds = $holdflds;
  968.         }
  969.     
  970.  
  971.         // already exists, alter table instead
  972.         list($lines,$pkey,$idxs) = $this->_GenFields($flds);
  973.         // genfields can return FALSE at times
  974.         if ($lines == null) $lines = array();
  975.         $alter = 'ALTER TABLE ' . $this->TableName($tablename);
  976.         $sql = array();
  977.  
  978.         foreach ( $lines as $id => $v ) {
  979.             if ( isset($cols[$id]) && is_object($cols[$id]) ) {
  980.             
  981.                 $flds = Lens_ParseArgs($v,',');
  982.                 
  983.                 //  We are trying to change the size of the field, if not allowed, simply ignore the request.
  984.                 // $flds[1] holds the type, $flds[2] holds the size -postnuke addition
  985.                 if ($flds && in_array(strtoupper(substr($flds[0][1],0,4)),$this->invalidResizeTypes4)
  986.                  && (isset($flds[0][2]) && is_numeric($flds[0][2]))) {
  987.                     if ($this->debug) ADOConnection::outp(sprintf("<h3>%s cannot be changed to %s currently</h3>", $flds[0][0], $flds[0][1]));
  988.                     #echo "<h3>$this->alterCol cannot be changed to $flds currently</h3>";
  989.                     continue;     
  990.                  }
  991.                 $sql[] = $alter . $this->alterCol . ' ' . $v;
  992.             } else {
  993.                 $sql[] = $alter . $this->addCol . ' ' . $v;
  994.             }
  995.         }
  996.         
  997.         return $sql;
  998.     }
  999. } // class
  1000. ?>