lib/adodb/adodb-active-record.inc.php

   1 <?php
   2 /*
   3
   4 @version   v5.20.16  12-Jan-2020
   5 @copyright (c) 2000-2013 John Lim (jlim#natsoft.com). All rights reserved.
   6 @copyright (c) 2014      Damien Regad, Mark Newnham and the ADOdb community
   7   Latest version is available at http://adodb.org/
   8
   9   Released under both BSD license and Lesser GPL library license.
  10   Whenever there is any discrepancy between the two licenses,
  11   the BSD license will take precedence.
  12
  13   Active Record implementation. Superset of Zend Framework's.
  14
  15   Version 0.92
  16
  17   See http://www-128.ibm.com/developerworks/java/library/j-cb03076/?ca=dgr-lnxw01ActiveRecord
  18         for info on Ruby on Rails Active Record implementation
  19 */
  20
  21
  22 global $_ADODB_ACTIVE_DBS;
  23 global $ADODB_ACTIVE_CACHESECS; // set to true to enable caching of metadata such as field info
  24 global $ACTIVE_RECORD_SAFETY; // set to false to disable safety checks
  25 global $ADODB_ACTIVE_DEFVALS; // use default values of table definition when creating new active record.
  26
  27 // array of ADODB_Active_DB's, indexed by ADODB_Active_Record->_dbat
  28 $_ADODB_ACTIVE_DBS = array();
  29 $ACTIVE_RECORD_SAFETY = true;
  30 $ADODB_ACTIVE_DEFVALS = false;
  31 $ADODB_ACTIVE_CACHESECS = 0;
  32
  33 class ADODB_Active_DB {
  34         var $db; // ADOConnection
  35         var $tables; // assoc array of ADODB_Active_Table objects, indexed by tablename
  36 }
  37
  38 class ADODB_Active_Table {
  39         var $name; // table name
  40         var $flds; // assoc array of adofieldobjs, indexed by fieldname
  41         var $keys; // assoc array of primary keys, indexed by fieldname
  42         var $_created; // only used when stored as a cached file
  43         var $_belongsTo = array();
  44         var $_hasMany = array();
  45 }
  46
  47 // $db = database connection
  48 // $index = name of index - can be associative, for an example see
  49 //    http://phplens.com/lens/lensforum/msgs.php?id=17790
  50 // returns index into $_ADODB_ACTIVE_DBS
  51 function ADODB_SetDatabaseAdapter(&$db, $index=false)
  52 {
  53         global $_ADODB_ACTIVE_DBS;
  54
  55                 foreach($_ADODB_ACTIVE_DBS as $k => $d) {
  56                         if (PHP_VERSION >= 5) {
  57                                 if ($d->db === $db) {
  58                                         return $k;
  59                                 }
  60                         } else {
  61                                 if ($d->db->_connectionID === $db->_connectionID && $db->database == $d->db->database) {
  62                                         return $k;
  63                                 }
  64                         }
  65                 }
  66
  67                 $obj = new ADODB_Active_DB();
  68                 $obj->db = $db;
  69                 $obj->tables = array();
  70
  71                 if ($index == false) {
  72                         $index = sizeof($_ADODB_ACTIVE_DBS);
  73                 }
  74
  75                 $_ADODB_ACTIVE_DBS[$index] = $obj;
  76
  77                 return sizeof($_ADODB_ACTIVE_DBS)-1;
  78 }
  79
  80
  81 class ADODB_Active_Record {
  82         static $_changeNames = true; // dynamically pluralize table names
  83         static $_quoteNames = false;
  84
  85         static $_foreignSuffix = '_id'; //
  86         var $_dbat; // associative index pointing to ADODB_Active_DB eg. $ADODB_Active_DBS[_dbat]
  87         var $_table; // tablename, if set in class definition then use it as table name
  88         var $_tableat; // associative index pointing to ADODB_Active_Table, eg $ADODB_Active_DBS[_dbat]->tables[$this->_tableat]
  89         var $_where; // where clause set in Load()
  90         var $_saved = false; // indicates whether data is already inserted.
  91         var $_lasterr = false; // last error message
  92         var $_original = false; // the original values loaded or inserted, refreshed on update
  93
  94         var $foreignName; // CFR: class name when in a relationship
  95
  96         var $lockMode = ' for update '; // you might want to change to
  97
  98         static function UseDefaultValues($bool=null)
  99         {
 100         global $ADODB_ACTIVE_DEFVALS;
 101                 if (isset($bool)) {
 102                         $ADODB_ACTIVE_DEFVALS = $bool;
 103                 }
 104                 return $ADODB_ACTIVE_DEFVALS;
 105         }
 106
 107         // should be static
 108         static function SetDatabaseAdapter(&$db, $index=false)
 109         {
 110                 return ADODB_SetDatabaseAdapter($db, $index);
 111         }
 112
 113
 114         public function __set($name, $value)
 115         {
 116                 $name = str_replace(' ', '_', $name);
 117                 $this->$name = $value;
 118         }
 119
 120         // php5 constructor
 121         function __construct($table = false, $pkeyarr=false, $db=false)
 122         {
 123         global $_ADODB_ACTIVE_DBS;
 124
 125                 if ($db == false && is_object($pkeyarr)) {
 126                         $db = $pkeyarr;
 127                         $pkeyarr = false;
 128                 }
 129
 130                 if (!$table) {
 131                         if (!empty($this->_table)) {
 132                                 $table = $this->_table;
 133                         }
 134                         else $table = $this->_pluralize(get_class($this));
 135                 }
 136                 $this->foreignName = strtolower(get_class($this)); // CFR: default foreign name
 137                 if ($db) {
 138                         $this->_dbat = ADODB_Active_Record::SetDatabaseAdapter($db);
 139                 } else if (!isset($this->_dbat)) {
 140                         if (sizeof($_ADODB_ACTIVE_DBS) == 0) {
 141                                 $this->Error(
 142                                         "No database connection set; use ADOdb_Active_Record::SetDatabaseAdapter(\$db)",
 143                                         'ADODB_Active_Record::__constructor'
 144                                 );
 145                         }
 146                         end($_ADODB_ACTIVE_DBS);
 147                         $this->_dbat = key($_ADODB_ACTIVE_DBS);
 148                 }
 149
 150                 $this->_table = $table;
 151                 $this->_tableat = $table; # reserved for setting the assoc value to a non-table name, eg. the sql string in future
 152
 153                 $this->UpdateActiveTable($pkeyarr);
 154         }
 155
 156         function __wakeup()
 157         {
 158                 $class = get_class($this);
 159                 new $class;
 160         }
 161
 162         function _pluralize($table)
 163         {
 164                 if (!ADODB_Active_Record::$_changeNames) {
 165                         return $table;
 166                 }
 167
 168                 $ut = strtoupper($table);
 169                 $len = strlen($table);
 170                 $lastc = $ut[$len-1];
 171                 $lastc2 = substr($ut,$len-2);
 172                 switch ($lastc) {
 173                 case 'S':
 174                         return $table.'es';
 175                 case 'Y':
 176                         return substr($table,0,$len-1).'ies';
 177                 case 'X':
 178                         return $table.'es';
 179                 case 'H':
 180                         if ($lastc2 == 'CH' || $lastc2 == 'SH') {
 181                                 return $table.'es';
 182                         }
 183                 default:
 184                         return $table.'s';
 185                 }
 186         }
 187
 188         // CFR Lamest singular inflector ever - @todo Make it real!
 189         // Note: There is an assumption here...and it is that the argument's length >= 4
 190         function _singularize($tables)
 191         {
 192
 193                 if (!ADODB_Active_Record::$_changeNames) {
 194                         return $table;
 195                 }
 196
 197                 $ut = strtoupper($tables);
 198                 $len = strlen($tables);
 199                 if($ut[$len-1] != 'S') {
 200                         return $tables; // I know...forget oxen
 201                 }
 202                 if($ut[$len-2] != 'E') {
 203                         return substr($tables, 0, $len-1);
 204                 }
 205                 switch($ut[$len-3]) {
 206                         case 'S':
 207                         case 'X':
 208                                 return substr($tables, 0, $len-2);
 209                         case 'I':
 210                                 return substr($tables, 0, $len-3) . 'y';
 211                         case 'H';
 212                                 if($ut[$len-4] == 'C' || $ut[$len-4] == 'S') {
 213                                         return substr($tables, 0, $len-2);
 214                                 }
 215                         default:
 216                                 return substr($tables, 0, $len-1); // ?
 217                 }
 218         }
 219
 220         function hasMany($foreignRef, $foreignKey = false, $foreignClass = 'ADODB_Active_Record')
 221         {
 222                 $ar = new $foreignClass($foreignRef);
 223                 $ar->foreignName = $foreignRef;
 224                 $ar->UpdateActiveTable();
 225                 $ar->foreignKey = ($foreignKey) ? $foreignKey : $foreignRef.ADODB_Active_Record::$_foreignSuffix;
 226                 $table =& $this->TableInfo();
 227                 $table->_hasMany[$foreignRef] = $ar;
 228         #       $this->$foreignRef = $this->_hasMany[$foreignRef]; // WATCHME Removed assignment by ref. to please __get()
 229         }
 230
 231         // use when you don't want ADOdb to auto-pluralize tablename
 232         static function TableHasMany($table, $foreignRef, $foreignKey = false, $foreignClass = 'ADODB_Active_Record')
 233         {
 234                 $ar = new ADODB_Active_Record($table);
 235                 $ar->hasMany($foreignRef, $foreignKey, $foreignClass);
 236         }
 237
 238         // use when you don't want ADOdb to auto-pluralize tablename
 239         static function TableKeyHasMany($table, $tablePKey, $foreignRef, $foreignKey = false, $foreignClass = 'ADODB_Active_Record')
 240         {
 241                 if (!is_array($tablePKey)) {
 242                         $tablePKey = array($tablePKey);
 243                 }
 244                 $ar = new ADODB_Active_Record($table,$tablePKey);
 245                 $ar->hasMany($foreignRef, $foreignKey, $foreignClass);
 246         }
 247
 248
 249         // use when you want ADOdb to auto-pluralize tablename for you. Note that the class must already be defined.
 250         // e.g. class Person will generate relationship for table Persons
 251         static function ClassHasMany($parentclass, $foreignRef, $foreignKey = false, $foreignClass = 'ADODB_Active_Record')
 252         {
 253                 $ar = new $parentclass();
 254                 $ar->hasMany($foreignRef, $foreignKey, $foreignClass);
 255         }
 256
 257
 258         function belongsTo($foreignRef,$foreignKey=false, $parentKey='', $parentClass = 'ADODB_Active_Record')
 259         {
 260                 global $inflector;
 261
 262                 $ar = new $parentClass($this->_pluralize($foreignRef));
 263                 $ar->foreignName = $foreignRef;
 264                 $ar->parentKey = $parentKey;
 265                 $ar->UpdateActiveTable();
 266                 $ar->foreignKey = ($foreignKey) ? $foreignKey : $foreignRef.ADODB_Active_Record::$_foreignSuffix;
 267
 268                 $table =& $this->TableInfo();
 269                 $table->_belongsTo[$foreignRef] = $ar;
 270         #       $this->$foreignRef = $this->_belongsTo[$foreignRef];
 271         }
 272
 273         static function ClassBelongsTo($class, $foreignRef, $foreignKey=false, $parentKey='', $parentClass = 'ADODB_Active_Record')
 274         {
 275                 $ar = new $class();
 276                 $ar->belongsTo($foreignRef, $foreignKey, $parentKey, $parentClass);
 277         }
 278
 279         static function TableBelongsTo($table, $foreignRef, $foreignKey=false, $parentKey='', $parentClass = 'ADODB_Active_Record')
 280         {
 281                 $ar = new ADOdb_Active_Record($table);
 282                 $ar->belongsTo($foreignRef, $foreignKey, $parentKey, $parentClass);
 283         }
 284
 285         static function TableKeyBelongsTo($table, $tablePKey, $foreignRef, $foreignKey=false, $parentKey='', $parentClass = 'ADODB_Active_Record')
 286         {
 287                 if (!is_array($tablePKey)) {
 288                         $tablePKey = array($tablePKey);
 289                 }
 290                 $ar = new ADOdb_Active_Record($table, $tablePKey);
 291                 $ar->belongsTo($foreignRef, $foreignKey, $parentKey, $parentClass);
 292         }
 293
 294
 295         /**
 296          * __get Access properties - used for lazy loading
 297          *
 298          * @param mixed $name
 299          * @access protected
 300          * @return mixed
 301          */
 302          function __get($name)
 303         {
 304                 return $this->LoadRelations($name, '', -1, -1);
 305         }
 306
 307         /**
 308          * @param string $name
 309          * @param string $whereOrderBy : eg. ' AND field1 = value ORDER BY field2'
 310          * @param offset
 311          * @param limit
 312          * @return mixed
 313          */
 314         function LoadRelations($name, $whereOrderBy='', $offset=-1,$limit=-1)
 315         {
 316                 $extras = array();
 317                 $table = $this->TableInfo();
 318                 if ($limit >= 0) {
 319                         $extras['limit'] = $limit;
 320                 }
 321                 if ($offset >= 0) {
 322                         $extras['offset'] = $offset;
 323                 }
 324
 325                 if (strlen($whereOrderBy)) {
 326                         if (!preg_match('/^[ \n\r]*AND/i', $whereOrderBy)) {
 327                                 if (!preg_match('/^[ \n\r]*ORDER[ \n\r]/i', $whereOrderBy)) {
 328                                         $whereOrderBy = 'AND ' . $whereOrderBy;
 329                                 }
 330                         }
 331                 }
 332
 333                 if(!empty($table->_belongsTo[$name])) {
 334                         $obj = $table->_belongsTo[$name];
 335                         $columnName = $obj->foreignKey;
 336                         if(empty($this->$columnName)) {
 337                                 $this->$name = null;
 338                         }
 339                         else {
 340                                 if ($obj->parentKey) {
 341                                         $key = $obj->parentKey;
 342                                 }
 343                                 else {
 344                                         $key = reset($table->keys);
 345                                 }
 346
 347                                 $arrayOfOne = $obj->Find($key.'='.$this->$columnName.' '.$whereOrderBy,false,false,$extras);
 348                                 if ($arrayOfOne) {
 349                                         $this->$name = $arrayOfOne[0];
 350                                         return $arrayOfOne[0];
 351                                 }
 352                         }
 353                 }
 354                 if(!empty($table->_hasMany[$name])) {
 355                         $obj = $table->_hasMany[$name];
 356                         $key = reset($table->keys);
 357                         $id = @$this->$key;
 358                         if (!is_numeric($id)) {
 359                                 $db = $this->DB();
 360                                 $id = $db->qstr($id);
 361                         }
 362                         $objs = $obj->Find($obj->foreignKey.'='.$id. ' '.$whereOrderBy,false,false,$extras);
 363                         if (!$objs) {
 364                                 $objs = array();
 365                         }
 366                         $this->$name = $objs;
 367                         return $objs;
 368                 }
 369
 370                 return array();
 371         }
 372         //////////////////////////////////
 373
 374         // update metadata
 375         function UpdateActiveTable($pkeys=false,$forceUpdate=false)
 376         {
 377         global $_ADODB_ACTIVE_DBS , $ADODB_CACHE_DIR, $ADODB_ACTIVE_CACHESECS;
 378         global $ADODB_ACTIVE_DEFVALS,$ADODB_FETCH_MODE;
 379
 380                 $activedb = $_ADODB_ACTIVE_DBS[$this->_dbat];
 381
 382                 $table = $this->_table;
 383                 $tables = $activedb->tables;
 384                 $tableat = $this->_tableat;
 385                 if (!$forceUpdate && !empty($tables[$tableat])) {
 386
 387                         $acttab = $tables[$tableat];
 388                         foreach($acttab->flds as $name => $fld) {
 389                                 if ($ADODB_ACTIVE_DEFVALS && isset($fld->default_value)) {
 390                                         $this->$name = $fld->default_value;
 391                                 }
 392                                 else {
 393                                         $this->$name = null;
 394                                 }
 395                         }
 396                         return;
 397                 }
 398                 $db = $activedb->db;
 399                 $fname = $ADODB_CACHE_DIR . '/adodb_' . $db->databaseType . '_active_'. $table . '.cache';
 400                 if (!$forceUpdate && $ADODB_ACTIVE_CACHESECS && $ADODB_CACHE_DIR && file_exists($fname)) {
 401                         $fp = fopen($fname,'r');
 402                         @flock($fp, LOCK_SH);
 403                         $acttab = unserialize(fread($fp,100000));
 404                         fclose($fp);
 405                         if ($acttab->_created + $ADODB_ACTIVE_CACHESECS - (abs(rand()) % 16) > time()) {
 406                                 // abs(rand()) randomizes deletion, reducing contention to delete/refresh file
 407                                 // ideally, you should cache at least 32 secs
 408
 409                                 foreach($acttab->flds as $name => $fld) {
 410                                         if ($ADODB_ACTIVE_DEFVALS && isset($fld->default_value)) {
 411                                                 $this->$name = $fld->default_value;
 412                                         }
 413                                         else {
 414                                                 $this->$name = null;
 415                                         }
 416                                 }
 417
 418                                 $activedb->tables[$table] = $acttab;
 419
 420                                 //if ($db->debug) ADOConnection::outp("Reading cached active record file: $fname");
 421                                 return;
 422                         } else if ($db->debug) {
 423                                 ADOConnection::outp("Refreshing cached active record file: $fname");
 424                         }
 425                 }
 426                 $activetab = new ADODB_Active_Table();
 427                 $activetab->name = $table;
 428
 429                 $save = $ADODB_FETCH_MODE;
 430                 $ADODB_FETCH_MODE = ADODB_FETCH_ASSOC;
 431                 if ($db->fetchMode !== false) {
 432                         $savem = $db->SetFetchMode(false);
 433                 }
 434
 435                 $cols = $db->MetaColumns($table);
 436
 437                 if (isset($savem)) {
 438                         $db->SetFetchMode($savem);
 439                 }
 440                 $ADODB_FETCH_MODE = $save;
 441
 442                 if (!$cols) {
 443                         $this->Error("Invalid table name: $table",'UpdateActiveTable');
 444                         return false;
 445                 }
 446                 $fld = reset($cols);
 447                 if (!$pkeys) {
 448                         if (isset($fld->primary_key)) {
 449                                 $pkeys = array();
 450                                 foreach($cols as $name => $fld) {
 451                                         if (!empty($fld->primary_key)) {
 452                                                 $pkeys[] = $name;
 453                                         }
 454                                 }
 455                         } else
 456                                 $pkeys = $this->GetPrimaryKeys($db, $table);
 457                 }
 458                 if (empty($pkeys)) {
 459                         $this->Error("No primary key found for table $table",'UpdateActiveTable');
 460                         return false;
 461                 }
 462
 463                 $attr = array();
 464                 $keys = array();
 465
 466                 switch (ADODB_ASSOC_CASE) {
 467                 case ADODB_ASSOC_CASE_LOWER:
 468                         foreach($cols as $name => $fldobj) {
 469                                 $name = strtolower($name);
 470                                 if ($ADODB_ACTIVE_DEFVALS && isset($fldobj->default_value)) {
 471                                         $this->$name = $fldobj->default_value;
 472                                 }
 473                                 else {
 474                                         $this->$name = null;
 475                                 }
 476                                 $attr[$name] = $fldobj;
 477                         }
 478                         foreach($pkeys as $k => $name) {
 479                                 $keys[strtolower($name)] = strtolower($name);
 480                         }
 481                         break;
 482
 483                 case ADODB_ASSOC_CASE_UPPER:
 484                         foreach($cols as $name => $fldobj) {
 485                                 $name = strtoupper($name);
 486
 487                                 if ($ADODB_ACTIVE_DEFVALS && isset($fldobj->default_value)) {
 488                                         $this->$name = $fldobj->default_value;
 489                                 }
 490                                 else {
 491                                         $this->$name = null;
 492                                 }
 493                                 $attr[$name] = $fldobj;
 494                         }
 495
 496                         foreach($pkeys as $k => $name) {
 497                                 $keys[strtoupper($name)] = strtoupper($name);
 498                         }
 499                         break;
 500                 default:
 501                         foreach($cols as $name => $fldobj) {
 502                                 $name = ($fldobj->name);
 503
 504                                 if ($ADODB_ACTIVE_DEFVALS && isset($fldobj->default_value)) {
 505                                         $this->$name = $fldobj->default_value;
 506                                 }
 507                                 else {
 508                                         $this->$name = null;
 509                                 }
 510                                 $attr[$name] = $fldobj;
 511                         }
 512                         foreach($pkeys as $k => $name) {
 513                                 $keys[$name] = $cols[$name]->name;
 514                         }
 515                         break;
 516                 }
 517
 518                 $activetab->keys = $keys;
 519                 $activetab->flds = $attr;
 520
 521                 if ($ADODB_ACTIVE_CACHESECS && $ADODB_CACHE_DIR) {
 522                         $activetab->_created = time();
 523                         $s = serialize($activetab);
 524                         if (!function_exists('adodb_write_file')) {
 525                                 include(ADODB_DIR.'/adodb-csvlib.inc.php');
 526                         }
 527                         adodb_write_file($fname,$s);
 528                 }
 529                 if (isset($activedb->tables[$table])) {
 530                         $oldtab = $activedb->tables[$table];
 531
 532                         if ($oldtab) {
 533                                 $activetab->_belongsTo = $oldtab->_belongsTo;
 534                                 $activetab->_hasMany = $oldtab->_hasMany;
 535                         }
 536                 }
 537                 $activedb->tables[$table] = $activetab;
 538         }
 539
 540         function GetPrimaryKeys(&$db, $table)
 541         {
 542                 return $db->MetaPrimaryKeys($table);
 543         }
 544
 545         // error handler for both PHP4+5.
 546         function Error($err,$fn)
 547         {
 548         global $_ADODB_ACTIVE_DBS;
 549
 550                 $fn = get_class($this).'::'.$fn;
 551                 $this->_lasterr = $fn.': '.$err;
 552
 553                 if ($this->_dbat < 0) {
 554                         $db = false;
 555                 }
 556                 else {
 557                         $activedb = $_ADODB_ACTIVE_DBS[$this->_dbat];
 558                         $db = $activedb->db;
 559                 }
 560
 561                 if (function_exists('adodb_throw')) {
 562                         if (!$db) {
 563                                 adodb_throw('ADOdb_Active_Record', $fn, -1, $err, 0, 0, false);
 564                         }
 565                         else {
 566                                 adodb_throw($db->databaseType, $fn, -1, $err, 0, 0, $db);
 567                         }
 568                 } else {
 569                         if (!$db || $db->debug) {
 570                                 ADOConnection::outp($this->_lasterr);
 571                         }
 572                 }
 573
 574         }
 575
 576         // return last error message
 577         function ErrorMsg()
 578         {
 579                 if (!function_exists('adodb_throw')) {
 580                         if ($this->_dbat < 0) {
 581                                 $db = false;
 582                         }
 583                         else {
 584                                 $db = $this->DB();
 585                         }
 586
 587                         // last error could be database error too
 588                         if ($db && $db->ErrorMsg()) {
 589                                 return $db->ErrorMsg();
 590                         }
 591                 }
 592                 return $this->_lasterr;
 593         }
 594
 595         function ErrorNo()
 596         {
 597                 if ($this->_dbat < 0) {
 598                         return -9999; // no database connection...
 599                 }
 600                 $db = $this->DB();
 601
 602                 return (int) $db->ErrorNo();
 603         }
 604
 605
 606         // retrieve ADOConnection from _ADODB_Active_DBs
 607         function DB()
 608         {
 609         global $_ADODB_ACTIVE_DBS;
 610
 611                 if ($this->_dbat < 0) {
 612                         $false = false;
 613                         $this->Error("No database connection set: use ADOdb_Active_Record::SetDatabaseAdaptor(\$db)", "DB");
 614                         return $false;
 615                 }
 616                 $activedb = $_ADODB_ACTIVE_DBS[$this->_dbat];
 617                 $db = $activedb->db;
 618                 return $db;
 619         }
 620
 621         // retrieve ADODB_Active_Table
 622         function &TableInfo()
 623         {
 624         global $_ADODB_ACTIVE_DBS;
 625                 $activedb = $_ADODB_ACTIVE_DBS[$this->_dbat];
 626                 $table = $activedb->tables[$this->_tableat];
 627                 return $table;
 628         }
 629
 630
 631         // I have an ON INSERT trigger on a table that sets other columns in the table.
 632         // So, I find that for myTable, I want to reload an active record after saving it. -- Malcolm Cook
 633         function Reload()
 634         {
 635                 $db = $this->DB();
 636                 if (!$db) {
 637                         return false;
 638                 }
 639                 $table = $this->TableInfo();
 640                 $where = $this->GenWhere($db, $table);
 641                 return($this->Load($where));
 642         }
 643
 644
 645         // set a numeric array (using natural table field ordering) as object properties
 646         function Set(&$row)
 647         {
 648         global $ACTIVE_RECORD_SAFETY;
 649
 650                 $db = $this->DB();
 651
 652                 if (!$row) {
 653                         $this->_saved = false;
 654                         return false;
 655                 }
 656
 657                 $this->_saved = true;
 658
 659                 $table = $this->TableInfo();
 660                 if ($ACTIVE_RECORD_SAFETY && sizeof($table->flds) != sizeof($row)) {
 661                         # <AP>
 662                         $bad_size = TRUE;
 663                         if (sizeof($row) == 2 * sizeof($table->flds)) {
 664                                 // Only keep string keys
 665                                 $keys = array_filter(array_keys($row), 'is_string');
 666                                 if (sizeof($keys) == sizeof($table->flds)) {
 667                                         $bad_size = FALSE;
 668                                 }
 669                         }
 670                         if ($bad_size) {
 671                         $this->Error("Table structure of $this->_table has changed","Load");
 672                         return false;
 673                 }
 674                         # </AP>
 675                 }
 676                 else
 677                         $keys = array_keys($row);
 678
 679                 # <AP>
 680                 reset($keys);
 681                 $this->_original = array();
 682                 foreach($table->flds as $name=>$fld) {
 683                         $value = $row[current($keys)];
 684                         $this->$name = $value;
 685                         $this->_original[] = $value;
 686                         next($keys);
 687                 }
 688
 689                 # </AP>
 690                 return true;
 691         }
 692
 693         // get last inserted id for INSERT
 694         function LastInsertID(&$db,$fieldname)
 695         {
 696                 if ($db->hasInsertID) {
 697                         $val = $db->Insert_ID($this->_table,$fieldname);
 698                 }
 699                 else {
 700                         $val = false;
 701                 }
 702
 703                 if (is_null($val) || $val === false) {
 704                         // this might not work reliably in multi-user environment
 705                         return $db->GetOne("select max(".$fieldname.") from ".$this->_table);
 706                 }
 707                 return $val;
 708         }
 709
 710         // quote data in where clause
 711         function doquote(&$db, $val,$t)
 712         {
 713                 switch($t) {
 714                 case 'L':
 715                         if (strpos($db->databaseType,'postgres') !== false) {
 716                                 return $db->qstr($val);
 717                         }
 718                 case 'D':
 719                 case 'T':
 720                         if (empty($val)) {
 721                                 return 'null';
 722                         }
 723                 case 'B':
 724                 case 'N':
 725                 case 'C':
 726                 case 'X':
 727                         if (is_null($val)) {
 728                                 return 'null';
 729                         }
 730
 731                         if (strlen($val)>0 &&
 732                                 (strncmp($val,"'",1) != 0 || substr($val,strlen($val)-1,1) != "'")
 733                         ) {
 734                                 return $db->qstr($val);
 735                                 break;
 736                         }
 737                 default:
 738                         return $val;
 739                         break;
 740                 }
 741         }
 742
 743         // generate where clause for an UPDATE/SELECT
 744         function GenWhere(&$db, &$table)
 745         {
 746                 $keys = $table->keys;
 747                 $parr = array();
 748
 749                 foreach($keys as $k) {
 750                         $f = $table->flds[$k];
 751                         if ($f) {
 752                                 $parr[] = $k.' = '.$this->doquote($db,$this->$k,$db->MetaType($f->type));
 753                         }
 754                 }
 755                 return implode(' and ', $parr);
 756         }
 757
 758
 759         function _QName($n,$db=false)
 760         {
 761                 if (!ADODB_Active_Record::$_quoteNames) {
 762                         return $n;
 763                 }
 764                 if (!$db) {
 765                         $db = $this->DB();
 766                         if (!$db) {
 767                                 return false;
 768                         }
 769                 }
 770                 return $db->nameQuote.$n.$db->nameQuote;
 771         }
 772
 773         //------------------------------------------------------------ Public functions below
 774
 775         function Load($where=null,$bindarr=false, $lock = false)
 776         {
 777         global $ADODB_FETCH_MODE;
 778
 779                 $db = $this->DB();
 780                 if (!$db) {
 781                         return false;
 782                 }
 783                 $this->_where = $where;
 784
 785                 $save = $ADODB_FETCH_MODE;
 786                 $ADODB_FETCH_MODE = ADODB_FETCH_NUM;
 787                 if ($db->fetchMode !== false) {
 788                         $savem = $db->SetFetchMode(false);
 789                 }
 790
 791                 $qry = "select * from ".$this->_table;
 792
 793                 if($where) {
 794                         $qry .= ' WHERE '.$where;
 795                 }
 796                 if ($lock) {
 797                         $qry .= $this->lockMode;
 798                 }
 799
 800                 $row = $db->GetRow($qry,$bindarr);
 801
 802                 if (isset($savem)) {
 803                         $db->SetFetchMode($savem);
 804                 }
 805                 $ADODB_FETCH_MODE = $save;
 806
 807                 return $this->Set($row);
 808         }
 809
 810         function LoadLocked($where=null, $bindarr=false)
 811         {
 812                 $this->Load($where,$bindarr,true);
 813         }
 814
 815         # useful for multiple record inserts
 816         # see http://phplens.com/lens/lensforum/msgs.php?id=17795
 817         function Reset()
 818         {
 819                 $this->_where=null;
 820                 $this->_saved = false;
 821                 $this->_lasterr = false;
 822                 $this->_original = false;
 823                 $vars=get_object_vars($this);
 824                 foreach($vars as $k=>$v){
 825                         if(substr($k,0,1)!=='_'){
 826                                 $this->{$k}=null;
 827                         }
 828                 }
 829                 $this->foreignName=strtolower(get_class($this));
 830                 return true;
 831         }
 832
 833         // false on error
 834         function Save()
 835         {
 836                 if ($this->_saved) {
 837                         $ok = $this->Update();
 838                 }
 839                 else {
 840                         $ok = $this->Insert();
 841                 }
 842
 843                 return $ok;
 844         }
 845
 846
 847         // false on error
 848         function Insert()
 849         {
 850                 $db = $this->DB();
 851                 if (!$db) {
 852                         return false;
 853                 }
 854                 $cnt = 0;
 855                 $table = $this->TableInfo();
 856
 857                 $valarr = array();
 858                 $names = array();
 859                 $valstr = array();
 860
 861                 foreach($table->flds as $name=>$fld) {
 862                         $val = $this->$name;
 863                         if(!is_array($val) || !is_null($val) || !array_key_exists($name, $table->keys)) {
 864                                 $valarr[] = $val;
 865                                 $names[] = $this->_QName($name,$db);
 866                                 $valstr[] = $db->Param($cnt);
 867                                 $cnt += 1;
 868                         }
 869                 }
 870
 871                 if (empty($names)){
 872                         foreach($table->flds as $name=>$fld) {
 873                                 $valarr[] = null;
 874                                 $names[] = $name;
 875                                 $valstr[] = $db->Param($cnt);
 876                                 $cnt += 1;
 877                         }
 878                 }
 879                 $sql = 'INSERT INTO '.$this->_table."(".implode(',',$names).') VALUES ('.implode(',',$valstr).')';
 880                 $ok = $db->Execute($sql,$valarr);
 881
 882                 if ($ok) {
 883                         $this->_saved = true;
 884                         $autoinc = false;
 885                         foreach($table->keys as $k) {
 886                                 if (is_null($this->$k)) {
 887                                         $autoinc = true;
 888                                         break;
 889                                 }
 890                         }
 891                         if ($autoinc && sizeof($table->keys) == 1) {
 892                                 $k = reset($table->keys);
 893                                 $this->$k = $this->LastInsertID($db,$k);
 894                         }
 895                 }
 896
 897                 $this->_original = $valarr;
 898                 return !empty($ok);
 899         }
 900
 901         function Delete()
 902         {
 903                 $db = $this->DB();
 904                 if (!$db) {
 905                         return false;
 906                 }
 907                 $table = $this->TableInfo();
 908
 909                 $where = $this->GenWhere($db,$table);
 910                 $sql = 'DELETE FROM '.$this->_table.' WHERE '.$where;
 911                 $ok = $db->Execute($sql);
 912
 913                 return $ok ? true : false;
 914         }
 915
 916         // returns an array of active record objects
 917         function Find($whereOrderBy,$bindarr=false,$pkeysArr=false,$extra=array())
 918         {
 919                 $db = $this->DB();
 920                 if (!$db || empty($this->_table)) {
 921                         return false;
 922                 }
 923                 $arr = $db->GetActiveRecordsClass(get_class($this),$this->_table, $whereOrderBy,$bindarr,$pkeysArr,$extra);
 924                 return $arr;
 925         }
 926
 927         // returns 0 on error, 1 on update, 2 on insert
 928         function Replace()
 929         {
 930                 $db = $this->DB();
 931                 if (!$db) {
 932                         return false;
 933                 }
 934                 $table = $this->TableInfo();
 935
 936                 $pkey = $table->keys;
 937
 938                 foreach($table->flds as $name=>$fld) {
 939                         $val = $this->$name;
 940                         /*
 941                         if (is_null($val)) {
 942                                 if (isset($fld->not_null) && $fld->not_null) {
 943                                         if (isset($fld->default_value) && strlen($fld->default_value)) {
 944                                                 continue;
 945                                         }
 946                                         else {
 947                                                 $this->Error("Cannot update null into $name","Replace");
 948                                                 return false;
 949                                         }
 950                                 }
 951                         }*/
 952                         if (is_null($val) && !empty($fld->auto_increment)) {
 953                                 continue;
 954                         }
 955
 956                         if (is_array($val)) {
 957                                 continue;
 958                         }
 959
 960                         $t = $db->MetaType($fld->type);
 961                         $arr[$name] = $this->doquote($db,$val,$t);
 962                         $valarr[] = $val;
 963                 }
 964
 965                 if (!is_array($pkey)) {
 966                         $pkey = array($pkey);
 967                 }
 968
 969                 switch (ADODB_ASSOC_CASE) {
 970                         case ADODB_ASSOC_CASE_LOWER:
 971                                 foreach ($pkey as $k => $v) {
 972                                         $pkey[$k] = strtolower($v);
 973                                 }
 974                                 break;
 975                         case ADODB_ASSOC_CASE_UPPER:
 976                                 foreach ($pkey as $k => $v) {
 977                                         $pkey[$k] = strtoupper($v);
 978                                 }
 979                                 break;
 980                 }
 981
 982                 $ok = $db->Replace($this->_table,$arr,$pkey);
 983                 if ($ok) {
 984                         $this->_saved = true; // 1= update 2=insert
 985                         if ($ok == 2) {
 986                                 $autoinc = false;
 987                                 foreach($table->keys as $k) {
 988                                         if (is_null($this->$k)) {
 989                                                 $autoinc = true;
 990                                                 break;
 991                                         }
 992                                 }
 993                                 if ($autoinc && sizeof($table->keys) == 1) {
 994                                         $k = reset($table->keys);
 995                                         $this->$k = $this->LastInsertID($db,$k);
 996                                 }
 997                         }
 998
 999                         $this->_original = $valarr;
1000                 }
1001                 return $ok;
1002         }
1003
1004         // returns 0 on error, 1 on update, -1 if no change in data (no update)
1005         function Update()
1006         {
1007                 $db = $this->DB();
1008                 if (!$db) {
1009                         return false;
1010                 }
1011                 $table = $this->TableInfo();
1012
1013                 $where = $this->GenWhere($db, $table);
1014
1015                 if (!$where) {
1016                         $this->error("Where missing for table $table", "Update");
1017                         return false;
1018                 }
1019                 $valarr = array();
1020                 $neworig = array();
1021                 $pairs = array();
1022                 $i = -1;
1023                 $cnt = 0;
1024                 foreach($table->flds as $name=>$fld) {
1025                         $i += 1;
1026                         $val = $this->$name;
1027                         $neworig[] = $val;
1028
1029                         if (isset($table->keys[$name]) || is_array($val)) {
1030                                 continue;
1031                         }
1032
1033                         if (is_null($val)) {
1034                                 if (isset($fld->not_null) && $fld->not_null) {
1035                                         if (isset($fld->default_value) && strlen($fld->default_value)) {
1036                                                 continue;
1037                                         }
1038                                         else {
1039                                                 $this->Error("Cannot set field $name to NULL","Update");
1040                                                 return false;
1041                                         }
1042                                 }
1043                         }
1044
1045                         if (isset($this->_original[$i]) && strcmp($val,$this->_original[$i]) == 0) {
1046                                 continue;
1047                         }
1048
1049                         if (is_null($this->_original[$i]) && is_null($val)) {
1050                                 continue;
1051                         }
1052
1053                         $valarr[] = $val;
1054                         $pairs[] = $this->_QName($name,$db).'='.$db->Param($cnt);
1055                         $cnt += 1;
1056                 }
1057
1058
1059                 if (!$cnt) {
1060                         return -1;
1061                 }
1062
1063                 $sql = 'UPDATE '.$this->_table." SET ".implode(",",$pairs)." WHERE ".$where;
1064                 $ok = $db->Execute($sql,$valarr);
1065                 if ($ok) {
1066                         $this->_original = $neworig;
1067                         return 1;
1068                 }
1069                 return 0;
1070         }
1071
1072         function GetAttributeNames()
1073         {
1074                 $table = $this->TableInfo();
1075                 if (!$table) {
1076                         return false;
1077                 }
1078                 return array_keys($table->flds);
1079         }
1080
1081 };
1082
1083 function adodb_GetActiveRecordsClass(&$db, $class, $table,$whereOrderBy,$bindarr, $primkeyArr,
1084                         $extra)
1085 {
1086 global $_ADODB_ACTIVE_DBS;
1087
1088
1089         $save = $db->SetFetchMode(ADODB_FETCH_NUM);
1090         $qry = "select * from ".$table;
1091
1092         if (!empty($whereOrderBy)) {
1093                 $qry .= ' WHERE '.$whereOrderBy;
1094         }
1095         if(isset($extra['limit'])) {
1096                 $rows = false;
1097                 if(isset($extra['offset'])) {
1098                         $rs = $db->SelectLimit($qry, $extra['limit'], $extra['offset'],$bindarr);
1099                 } else {
1100                         $rs = $db->SelectLimit($qry, $extra['limit'],-1,$bindarr);
1101                 }
1102                 if ($rs) {
1103                         while (!$rs->EOF) {
1104                                 $rows[] = $rs->fields;
1105                                 $rs->MoveNext();
1106                         }
1107                 }
1108         } else
1109                 $rows = $db->GetAll($qry,$bindarr);
1110
1111         $db->SetFetchMode($save);
1112
1113         $false = false;
1114
1115         if ($rows === false) {
1116                 return $false;
1117         }
1118
1119
1120         if (!class_exists($class)) {
1121                 $db->outp_throw("Unknown class $class in GetActiveRecordsClass()",'GetActiveRecordsClass');
1122                 return $false;
1123         }
1124         $arr = array();
1125         // arrRef will be the structure that knows about our objects.
1126         // It is an associative array.
1127         // We will, however, return arr, preserving regular 0.. order so that
1128         // obj[0] can be used by app developpers.
1129         $arrRef = array();
1130         $bTos = array(); // Will store belongTo's indices if any
1131         foreach($rows as $row) {
1132
1133                 $obj = new $class($table,$primkeyArr,$db);
1134                 if ($obj->ErrorNo()){
1135                         $db->_errorMsg = $obj->ErrorMsg();
1136                         return $false;
1137                 }
1138                 $obj->Set($row);
1139                 $arr[] = $obj;
1140         } // foreach($rows as $row)
1141
1142         return $arr;
1143 }