lib/WikiDB/adodb/adodb-lib.inc.php

   1 <?php
   2
   3 global $ADODB_INCLUDED_LIB;
   4 $ADODB_INCLUDED_LIB = 1;
   5
   6 /*
   7  @version V4.22 15 Apr 2004 (c) 2000-2004 John Lim (jlim\@natsoft.com.my). All rights reserved.
   8   Released under both BSD license and Lesser GPL library license.
   9   Whenever there is any discrepancy between the two licenses,
  10   the BSD license will take precedence. See License.txt.
  11   Set tabs to 4 for best viewing.
  12
  13   Less commonly used functions are placed here to reduce size of adodb.inc.php.
  14 */
  15
  16
  17 // Force key to upper.
  18 // See also http://www.php.net/manual/en/function.array-change-key-case.php
  19 function _array_change_key_case($an_array)
  20 {
  21         if (is_array($an_array)) {
  22                 foreach($an_array as $key=>$value)
  23                         $new_array[strtoupper($key)] = $value;
  24
  25                 return $new_array;
  26    }
  27
  28         return $an_array;
  29 }
  30
  31 function _adodb_replace(&$zthis, $table, $fieldArray, $keyCol, $autoQuote, $has_autoinc)
  32 {
  33                 if (count($fieldArray) == 0) return 0;
  34                 $first = true;
  35                 $uSet = '';
  36
  37                 if (!is_array($keyCol)) {
  38                         $keyCol = array($keyCol);
  39                 }
  40                 foreach($fieldArray as $k => $v) {
  41                         if ($autoQuote && !is_numeric($v) and strncmp($v,"'",1) !== 0 and strcasecmp($v,'null')!=0) {
  42                                 $v = $zthis->qstr($v);
  43                                 $fieldArray[$k] = $v;
  44                         }
  45                         if (in_array($k,$keyCol)) continue; // skip UPDATE if is key
  46
  47                         if ($first) {
  48                                 $first = false;
  49                                 $uSet = "$k=$v";
  50                         } else
  51                                 $uSet .= ",$k=$v";
  52                 }
  53
  54                 $where = false;
  55                 foreach ($keyCol as $v) {
  56                         if ($where) $where .= " and $v=$fieldArray[$v]";
  57                         else $where = "$v=$fieldArray[$v]";
  58                 }
  59
  60                 if ($uSet && $where) {
  61                         $update = "UPDATE $table SET $uSet WHERE $where";
  62
  63                         $rs = $zthis->Execute($update);
  64                         if ($rs) {
  65                                 if ($zthis->poorAffectedRows) {
  66                                 /*
  67                                  The Select count(*) wipes out any errors that the update would have returned.
  68                                 http://phplens.com/lens/lensforum/msgs.php?id=5696
  69                                 */
  70                                         if ($zthis->ErrorNo()<>0) return 0;
  71
  72                                 # affected_rows == 0 if update field values identical to old values
  73                                 # for mysql - which is silly.
  74
  75                                         $cnt = $zthis->GetOne("select count(*) from $table where $where");
  76                                         if ($cnt > 0) return 1; // record already exists
  77                                 } else
  78                                          if (($zthis->Affected_Rows()>0)) return 1;
  79                         }
  80                 }
  81         //      print "<p>Error=".$this->ErrorNo().'<p>';
  82                 $first = true;
  83                 foreach($fieldArray as $k => $v) {
  84                         if ($has_autoinc && in_array($k,$keyCol)) continue; // skip autoinc col
  85
  86                         if ($first) {
  87                                 $first = false;
  88                                 $iCols = "$k";
  89                                 $iVals = "$v";
  90                         } else {
  91                                 $iCols .= ",$k";
  92                                 $iVals .= ",$v";
  93                         }
  94                 }
  95                 $insert = "INSERT INTO $table ($iCols) VALUES ($iVals)";
  96                 $rs = $zthis->Execute($insert);
  97                 return ($rs) ? 2 : 0;
  98 }
  99
 100 // Requires $ADODB_FETCH_MODE = ADODB_FETCH_NUM
 101 function _adodb_getmenu(&$zthis, $name,$defstr='',$blank1stItem=true,$multiple=false,
 102                         $size=0, $selectAttr='',$compareFields0=true)
 103 {
 104         $hasvalue = false;
 105
 106         if ($multiple or is_array($defstr)) {
 107                 if ($size==0) $size=5;
 108                 $attr = " multiple size=$size";
 109                 if (!strpos($name,'[]')) $name .= '[]';
 110         } else if ($size) $attr = " size=$size";
 111         else $attr ='';
 112
 113         $s = "<select name=\"$name\"$attr $selectAttr>";
 114         if ($blank1stItem)
 115                 if (is_string($blank1stItem))  {
 116                         $barr = explode(':',$blank1stItem);
 117                         if (sizeof($barr) == 1) $barr[] = '';
 118                         $s .= "\n<option value=\"".$barr[0]."\">".$barr[1]."</option>";
 119                 } else $s .= "\n<option></option>";
 120
 121         if ($zthis->FieldCount() > 1) $hasvalue=true;
 122         else $compareFields0 = true;
 123
 124         $value = '';
 125         while(!$zthis->EOF) {
 126                 $zval = rtrim(reset($zthis->fields));
 127                 if (sizeof($zthis->fields) > 1) {
 128                         if (isset($zthis->fields[1]))
 129                                 $zval2 = rtrim($zthis->fields[1]);
 130                         else
 131                                 $zval2 = rtrim(next($zthis->fields));
 132                 }
 133                 $selected = ($compareFields0) ? $zval : $zval2;
 134
 135                 if ($blank1stItem && $zval=="") {
 136                         $zthis->MoveNext();
 137                         continue;
 138                 }
 139                 if ($hasvalue)
 140                         $value = ' value="'.htmlspecialchars($zval2).'"';
 141
 142                 if (is_array($defstr))  {
 143
 144                         if (in_array($selected,$defstr))
 145                                 $s .= "<option selected$value>".htmlspecialchars($zval).'</option>';
 146                         else
 147                                 $s .= "\n<option".$value.'>'.htmlspecialchars($zval).'</option>';
 148                 }
 149                 else {
 150                         if (strcasecmp($selected,$defstr)==0)
 151                                 $s .= "<option selected$value>".htmlspecialchars($zval).'</option>';
 152                         else
 153                                 $s .= "\n<option".$value.'>'.htmlspecialchars($zval).'</option>';
 154                 }
 155                 $zthis->MoveNext();
 156         } // while
 157
 158         return $s ."\n</select>\n";
 159 }
 160
 161 /*
 162         Count the number of records this sql statement will return by using
 163         query rewriting techniques...
 164
 165         Does not work with UNIONs.
 166 */
 167 function _adodb_getcount(&$zthis, $sql,$inputarr=false,$secs2cache=0)
 168 {
 169         $qryRecs = 0;
 170
 171          if (preg_match("/^\s*SELECT\s+DISTINCT/is", $sql) || preg_match('/\s+GROUP\s+BY\s+/is',$sql)) {
 172                 // ok, has SELECT DISTINCT or GROUP BY so see if we can use a table alias
 173                 // but this is only supported by oracle and postgresql...
 174                 if ($zthis->dataProvider == 'oci8') {
 175
 176                         $rewritesql = preg_replace('/(\sORDER\s+BY\s.*)/is','',$sql);
 177                         $rewritesql = "SELECT COUNT(*) FROM ($rewritesql)";
 178
 179                 } else if ( $zthis->databaseType == 'postgres' || $zthis->databaseType == 'postgres7')  {
 180
 181                         $info = $zthis->ServerInfo();
 182                         if (substr($info['version'],0,3) >= 7.1) { // good till version 999
 183                                 $rewritesql = preg_replace('/(\sORDER\s+BY\s.*)/is','',$sql);
 184                                 $rewritesql = "SELECT COUNT(*) FROM ($rewritesql) _ADODB_ALIAS_";
 185                         }
 186                 }
 187         } else {
 188                 // now replace SELECT ... FROM with SELECT COUNT(*) FROM
 189
 190                 $rewritesql = preg_replace(
 191                                         '/^\s*SELECT\s.*\s+FROM\s/Uis','SELECT COUNT(*) FROM ',$sql);
 192
 193                 // fix by alexander zhukov, alex#unipack.ru, because count(*) and 'order by' fails
 194                 // with mssql, access and postgresql. Also a good speedup optimization - skips sorting!
 195                 $rewritesql = preg_replace('/(\sORDER\s+BY\s.*)/is','',$rewritesql);
 196         }
 197
 198         if (isset($rewritesql) && $rewritesql != $sql) {
 199                 if ($secs2cache) {
 200                         // we only use half the time of secs2cache because the count can quickly
 201                         // become inaccurate if new records are added
 202                         $qryRecs = $zthis->CacheGetOne($secs2cache/2,$rewritesql,$inputarr);
 203
 204                 } else {
 205                         $qryRecs = $zthis->GetOne($rewritesql,$inputarr);
 206                 }
 207                 if ($qryRecs !== false) return $qryRecs;
 208         }
 209
 210         //--------------------------------------------
 211         // query rewrite failed - so try slower way...
 212
 213         // strip off unneeded ORDER BY
 214         $rewritesql = preg_replace('/(\sORDER\s+BY\s.*)/is','',$sql);
 215         $rstest = &$zthis->Execute($rewritesql,$inputarr);
 216         if ($rstest) {
 217                         $qryRecs = $rstest->RecordCount();
 218                 if ($qryRecs == -1) {
 219                 global $ADODB_EXTENSION;
 220                 // some databases will return -1 on MoveLast() - change to MoveNext()
 221                         if ($ADODB_EXTENSION) {
 222                                 while(!$rstest->EOF) {
 223                                         adodb_movenext($rstest);
 224                                 }
 225                         } else {
 226                                 while(!$rstest->EOF) {
 227                                         $rstest->MoveNext();
 228                                 }
 229                         }
 230                         $qryRecs = $rstest->_currentRow;
 231                 }
 232                 $rstest->Close();
 233                 if ($qryRecs == -1) return 0;
 234         }
 235
 236         return $qryRecs;
 237 }
 238
 239 /*
 240         Code originally from "Cornel G" <conyg@fx.ro>
 241
 242         This code will not work with SQL that has UNION in it
 243
 244         Also if you are using CachePageExecute(), there is a strong possibility that
 245         data will get out of synch. use CachePageExecute() only with tables that
 246         rarely change.
 247 */
 248 function &_adodb_pageexecute_all_rows(&$zthis, $sql, $nrows, $page,
 249                                                 $inputarr=false, $secs2cache=0)
 250 {
 251         $atfirstpage = false;
 252         $atlastpage = false;
 253         $lastpageno=1;
 254
 255         // If an invalid nrows is supplied,
 256         // we assume a default value of 10 rows per page
 257         if (!isset($nrows) || $nrows <= 0) $nrows = 10;
 258
 259         $qryRecs = false; //count records for no offset
 260
 261         $qryRecs = _adodb_getcount($zthis,$sql,$inputarr,$secs2cache);
 262         $lastpageno = (int) ceil($qryRecs / $nrows);
 263         $zthis->_maxRecordCount = $qryRecs;
 264
 265         // If page number <= 1, then we are at the first page
 266         if (!isset($page) || $page <= 1) {
 267                 $page = 1;
 268                 $atfirstpage = true;
 269         }
 270
 271         // ***** Here we check whether $page is the last page or
 272         // whether we are trying to retrieve
 273         // a page number greater than the last page number.
 274         if ($page >= $lastpageno) {
 275                 $page = $lastpageno;
 276                 $atlastpage = true;
 277         }
 278
 279         // We get the data we want
 280         $offset = $nrows * ($page-1);
 281         if ($secs2cache > 0)
 282                 $rsreturn = &$zthis->CacheSelectLimit($secs2cache, $sql, $nrows, $offset, $inputarr);
 283         else
 284                 $rsreturn = &$zthis->SelectLimit($sql, $nrows, $offset, $inputarr, $secs2cache);
 285
 286
 287         // Before returning the RecordSet, we set the pagination properties we need
 288         if ($rsreturn) {
 289                 $rsreturn->_maxRecordCount = $qryRecs;
 290                 $rsreturn->rowsPerPage = $nrows;
 291                 $rsreturn->AbsolutePage($page);
 292                 $rsreturn->AtFirstPage($atfirstpage);
 293                 $rsreturn->AtLastPage($atlastpage);
 294                 $rsreturn->LastPageNo($lastpageno);
 295         }
 296         return $rsreturn;
 297 }
 298
 299 // Iván Oliva version
 300 function &_adodb_pageexecute_no_last_page(&$zthis, $sql, $nrows, $page, $inputarr=false, $secs2cache=0)
 301 {
 302
 303         $atfirstpage = false;
 304         $atlastpage = false;
 305
 306         if (!isset($page) || $page <= 1) {      // If page number <= 1, then we are at the first page
 307                 $page = 1;
 308                 $atfirstpage = true;
 309         }
 310         if ($nrows <= 0) $nrows = 10;   // If an invalid nrows is supplied, we assume a default value of 10 rows per page
 311
 312         // ***** Here we check whether $page is the last page or whether we are trying to retrieve a page number greater than
 313         // the last page number.
 314         $pagecounter = $page + 1;
 315         $pagecounteroffset = ($pagecounter * $nrows) - $nrows;
 316         if ($secs2cache>0) $rstest = &$zthis->CacheSelectLimit($secs2cache, $sql, $nrows, $pagecounteroffset, $inputarr);
 317         else $rstest = &$zthis->SelectLimit($sql, $nrows, $pagecounteroffset, $inputarr, $secs2cache);
 318         if ($rstest) {
 319                 while ($rstest && $rstest->EOF && $pagecounter>0) {
 320                         $atlastpage = true;
 321                         $pagecounter--;
 322                         $pagecounteroffset = $nrows * ($pagecounter - 1);
 323                         $rstest->Close();
 324                         if ($secs2cache>0) $rstest = &$zthis->CacheSelectLimit($secs2cache, $sql, $nrows, $pagecounteroffset, $inputarr);
 325                         else $rstest = &$zthis->SelectLimit($sql, $nrows, $pagecounteroffset, $inputarr, $secs2cache);
 326                 }
 327                 if ($rstest) $rstest->Close();
 328         }
 329         if ($atlastpage) {      // If we are at the last page or beyond it, we are going to retrieve it
 330                 $page = $pagecounter;
 331                 if ($page == 1) $atfirstpage = true;    // We have to do this again in case the last page is the same as the first
 332                         //... page, that is, the recordset has only 1 page.
 333         }
 334
 335         // We get the data we want
 336         $offset = $nrows * ($page-1);
 337         if ($secs2cache > 0) $rsreturn = &$zthis->CacheSelectLimit($secs2cache, $sql, $nrows, $offset, $inputarr);
 338         else $rsreturn = &$zthis->SelectLimit($sql, $nrows, $offset, $inputarr, $secs2cache);
 339
 340         // Before returning the RecordSet, we set the pagination properties we need
 341         if ($rsreturn) {
 342                 $rsreturn->rowsPerPage = $nrows;
 343                 $rsreturn->AbsolutePage($page);
 344                 $rsreturn->AtFirstPage($atfirstpage);
 345                 $rsreturn->AtLastPage($atlastpage);
 346         }
 347         return $rsreturn;
 348 }
 349
 350 function _adodb_getupdatesql(&$zthis,&$rs, $arrFields,$forceUpdate=false,$magicq=false)
 351 {
 352                 if (!$rs) {
 353                         printf(ADODB_BAD_RS,'GetUpdateSQL');
 354                         return false;
 355                 }
 356
 357                 $fieldUpdatedCount = 0;
 358                 $arrFields = _array_change_key_case($arrFields);
 359
 360                 $hasnumeric = isset($rs->fields[0]);
 361                 $setFields = '';
 362
 363                 // Loop through all of the fields in the recordset
 364                 for ($i=0, $max=$rs->FieldCount(); $i < $max; $i++) {
 365                         // Get the field from the recordset
 366                         $field = $rs->FetchField($i);
 367
 368                         // If the recordset field is one
 369                         // of the fields passed in then process.
 370                         $upperfname = strtoupper($field->name);
 371                         if (adodb_key_exists($upperfname,$arrFields)) {
 372
 373                                 // If the existing field value in the recordset
 374                                 // is different from the value passed in then
 375                                 // go ahead and append the field name and new value to
 376                                 // the update query.
 377
 378                                 if ($hasnumeric) $val = $rs->fields[$i];
 379                                 else if (isset($rs->fields[$upperfname])) $val = $rs->fields[$upperfname];
 380                                 else if (isset($rs->fields[$field->name])) $val =  $rs->fields[$field->name];
 381                                 else if (isset($rs->fields[strtolower($upperfname)])) $val =  $rs->fields[strtolower($upperfname)];
 382                                 else $val = '';
 383
 384
 385                                 if ($forceUpdate || strcmp($val, $arrFields[$upperfname])) {
 386                                         // Set the counter for the number of fields that will be updated.
 387                                         $fieldUpdatedCount++;
 388
 389                                         // Based on the datatype of the field
 390                                         // Format the value properly for the database
 391                                 $type = $rs->MetaType($field->type);
 392
 393                                         // is_null requires php 4.0.4
 394                                 if ((defined('ADODB_FORCE_NULLS') && is_null($arrFields[$upperfname])) ||
 395                                         $arrFields[$upperfname] === 'null') {
 396                                         $setFields .= $field->name . " = null, ";
 397                                 } else {
 398                                         if ($type == 'null') {
 399                                                 $type = 'C';
 400                                         }
 401                                         //we do this so each driver can customize the sql for
 402                                         //DB specific column types.
 403                                         //Oracle needs BLOB types to be handled with a returning clause
 404                                         //postgres has special needs as well
 405                                         $setFields .= _adodb_column_sql($zthis, 'U', $type, $upperfname,
 406                                                                                                           $arrFields, $magicq);
 407                                 }
 408                         }
 409                 }
 410         }
 411
 412                 // If there were any modified fields then build the rest of the update query.
 413                 if ($fieldUpdatedCount > 0 || $forceUpdate) {
 414                                         // Get the table name from the existing query.
 415                         preg_match("/FROM\s+".ADODB_TABLE_REGEX."/is", $rs->sql, $tableName);
 416
 417                         // Get the full where clause excluding the word "WHERE" from
 418                         // the existing query.
 419                         preg_match('/\sWHERE\s(.*)/is', $rs->sql, $whereClause);
 420
 421                         $discard = false;
 422                         // not a good hack, improvements?
 423                         if ($whereClause)
 424                                 preg_match('/\s(LIMIT\s.*)/is', $whereClause[1], $discard);
 425                         else
 426                                 $whereClause = array(false,false);
 427
 428                         if ($discard)
 429                                 $whereClause[1] = substr($whereClause[1], 0, strlen($whereClause[1]) - strlen($discard[1]));
 430
 431                 $sql = 'UPDATE '.$tableName[1].' SET '.substr($setFields, 0, -2);
 432                 if (strlen($whereClause[1]) > 0)
 433                         $sql .= ' WHERE '.$whereClause[1];
 434
 435                 return $sql;
 436
 437                 } else {
 438                         return false;
 439         }
 440 }
 441
 442 function adodb_key_exists($key, &$arr)
 443 {
 444         if (!defined('ADODB_FORCE_NULLS')) {
 445                 // the following is the old behaviour where null or empty fields are ignored
 446                 return (!empty($arr[$key])) || (isset($arr[$key]) && strlen($arr[$key])>0);
 447         }
 448
 449         if (isset($arr[$key])) return true;
 450         ## null check below
 451         if (ADODB_PHPVER >= 0x4010) return array_key_exists($key,$arr);
 452         return false;
 453 }
 454
 455 /**
 456  * There is a special case of this function for the oci8 driver.
 457  * The proper way to handle an insert w/ a blob in oracle requires
 458  * a returning clause with bind variables and a descriptor blob.
 459  *
 460  *
 461  */
 462 function _adodb_getinsertsql(&$zthis,&$rs,$arrFields,$magicq=false)
 463 {
 464         $tableName = '';
 465         $values = '';
 466         $fields = '';
 467         $recordSet = null;
 468         $arrFields = _array_change_key_case($arrFields);
 469         $fieldInsertedCount = 0;
 470
 471         if (is_string($rs)) {
 472                 //ok we have a table name
 473                 //try and get the column info ourself.
 474                 $tableName = $rs;
 475
 476                 //we need an object for the recordSet
 477                 //because we have to call MetaType.
 478                 //php can't do a $rsclass::MetaType()
 479                 $rsclass = $zthis->rsPrefix.$zthis->databaseType;
 480                 $recordSet =& new $rsclass(-1,$zthis->fetchMode);
 481                 $recordSet->connection = &$zthis;
 482
 483                 $columns = $zthis->MetaColumns( $tableName );
 484         } else if (is_subclass_of($rs, 'adorecordset')) {
 485                 for ($i=0, $max=$rs->FieldCount(); $i < $max; $i++)
 486                         $columns[] = $rs->FetchField($i);
 487                 $recordSet =& $rs;
 488
 489         } else {
 490                 printf(ADODB_BAD_RS,'GetInsertSQL');
 491                 return false;
 492         }
 493
 494         // Loop through all of the fields in the recordset
 495         foreach( $columns as $field ) {
 496                 $upperfname = strtoupper($field->name);
 497                 if (adodb_key_exists($upperfname,$arrFields)) {
 498
 499                         // Set the counter for the number of fields that will be inserted.
 500                         $fieldInsertedCount++;
 501
 502                         // Get the name of the fields to insert
 503                         $fields .= $field->name . ", ";
 504
 505                         $type = $recordSet->MetaType($field->type);
 506
 507                         if ((defined('ADODB_FORCE_NULLS') && is_null($arrFields[$upperfname])) ||
 508                                 $arrFields[$upperfname] === 'null') {
 509                                 $values  .= "null, ";
 510                         } else {
 511                                 //we do this so each driver can customize the sql for
 512                                 //DB specific column types.
 513                                 //Oracle needs BLOB types to be handled with a returning clause
 514                                 //postgres has special needs as well
 515                                 $values .= _adodb_column_sql($zthis, 'I', $type, $upperfname,
 516                                                                                            $arrFields, $magicq);
 517                         }
 518                 }
 519         }
 520
 521
 522         // If there were any inserted fields then build the rest of the insert query.
 523         if ($fieldInsertedCount <= 0)  return false;
 524
 525         // Get the table name from the existing query.
 526         if (!$tableName) {
 527                 preg_match("/FROM\s+".ADODB_TABLE_REGEX."/is", $rs->sql, $tableName);
 528                         $tableName = $tableName[1];
 529         }
 530
 531         // Strip off the comma and space on the end of both the fields
 532         // and their values.
 533         $fields = substr($fields, 0, -2);
 534         $values = substr($values, 0, -2);
 535
 536         // Append the fields and their values to the insert query.
 537         return 'INSERT INTO '.$tableName.' ( '.$fields.' ) VALUES ( '.$values.' )';
 538 }
 539
 540
 541 /**
 542  * This private method is used to help construct
 543  * the update/sql which is generated by GetInsertSQL and GetUpdateSQL.
 544  * It handles the string construction of 1 column -> sql string based on
 545  * the column type.  We want to do 'safe' handling of BLOBs
 546  *
 547  * @param string the type of sql we are trying to create
 548  *                'I' or 'U'.
 549  * @param string column data type from the db::MetaType() method
 550  * @param string the column name
 551  * @param array the column value
 552  *
 553  * @return string
 554  *
 555  */
 556 function _adodb_column_sql_oci8(&$zthis,$action, $type, $fname, $arrFields, $magicq)
 557 {
 558     $sql = '';
 559
 560     // Based on the datatype of the field
 561     // Format the value properly for the database
 562     switch($type) {
 563     case 'B':
 564         //in order to handle Blobs correctly, we need
 565         //to do some magic for Oracle
 566
 567         //we need to create a new descriptor to handle
 568         //this properly
 569         if (!empty($zthis->hasReturningInto)) {
 570             if ($action == 'I') {
 571                 $sql = 'empty_blob(), ';
 572             } else {
 573                 $sql = $fname. '=empty_blob(), ';
 574             }
 575             //add the variable to the returning clause array
 576             //so the user can build this later in
 577             //case they want to add more to it
 578             $zthis->_returningArray[$fname] = ':xx'.$fname.'xx';
 579         } else {
 580             //this is to maintain compatibility
 581             //with older adodb versions.
 582             $sql = _adodb_column_sql($zthis, $action, $type, $fname, $arrFields, $magicq,false);
 583         }
 584         break;
 585
 586     case "X":
 587         //we need to do some more magic here for long variables
 588         //to handle these correctly in oracle.
 589
 590         //create a safe bind var name
 591         //to avoid conflicts w/ dupes.
 592        if (!empty($zthis->hasReturningInto)) {
 593             if ($action == 'I') {
 594                 $sql = ':xx'.$fname.'xx, ';
 595             } else {
 596                 $sql = $fname.'=:xx'.$fname.'xx, ';
 597             }
 598             //add the variable to the returning clause array
 599             //so the user can build this later in
 600             //case they want to add more to it
 601             $zthis->_returningArray[$fname] = ':xx'.$fname.'xx';
 602         } else {
 603             //this is to maintain compatibility
 604             //with older adodb versions.
 605             $sql = _adodb_column_sql($zthis, $action, $type, $fname, $arrFields, $magicq,false);
 606         }
 607         break;
 608
 609     default:
 610         $sql = _adodb_column_sql($zthis, $action, $type, $fname, $arrFields, $magicq,false);
 611         break;
 612     }
 613
 614     return $sql;
 615 }
 616
 617 function _adodb_column_sql(&$zthis, $action, $type, $fname, $arrFields, $magicq, $recurse=true)
 618 {
 619
 620         if ($recurse) {
 621                 switch($zthis->dataProvider)  {
 622                 case 'postgres':
 623                         if ($type == 'L') $type = 'C';
 624                         break;
 625                 case 'oci8':
 626                         return _adodb_column_sql_oci8($zthis, $action, $type, $fname, $arrFields, $magicq);
 627
 628                 }
 629         }
 630
 631         $sql = '';
 632
 633         switch($type) {
 634                 case "C":
 635                 case "X":
 636                 case 'B':
 637                         if ($action == 'I') {
 638                                 $sql = $zthis->qstr($arrFields[$fname],$magicq) . ", ";
 639                         } else {
 640                                 $sql .= $fname . "=" . $zthis->qstr($arrFields[$fname],$magicq) . ", ";
 641                         }
 642                   break;
 643
 644                 case "D":
 645                         if ($action == 'I') {
 646                                 $sql = $zthis->DBDate($arrFields[$fname]) . ", ";
 647                         } else {
 648                                 $sql .= $fname . "=" . $zthis->DBDate($arrFields[$fname]) . ", ";
 649                         }
 650                         break;
 651
 652                 case "T":
 653                         if ($action == 'I') {
 654                                 $sql = $zthis->DBTimeStamp($arrFields[$fname]) . ", ";
 655                         } else {
 656                                 $sql .= $fname . "=" . $zthis->DBTimeStamp($arrFields[$fname]) . ", ";
 657                         }
 658                         break;
 659
 660                 default:
 661                         $val = $arrFields[$fname];
 662                         if (empty($val)) $val = '0';
 663
 664
 665                         if ($action == 'I') {
 666                                 $sql .= $val . ", ";
 667                         } else {
 668                                 $sql .= $fname . "=" . $val  . ", ";
 669                         }
 670                         break;
 671         }
 672
 673         return $sql;
 674 }
 675 ?>