?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Space to separate "&&" so that all "&$var" can be made into "$var" later
[openemr.git] / library / adodb / adodb-active-recordx.inc.php
blob994b86b8553317fbc3dd061abe88686d31281428
1 <?php
2 /*
3
4 @version V5.06 29 Sept 2008 (c) 2000-2011 John Lim (jlim#natsoft.com). All rights reserved.
5 Latest version is available at http://adodb.sourceforge.net
6
7 Released under both BSD license and Lesser GPL library license.
8 Whenever there is any discrepancy between the two licenses,
9 the BSD license will take precedence.
10
11 Active Record implementation. Superset of Zend Framework's.
12
13 This is "Active Record eXtended" to support JOIN, WORK and LAZY mode by Chris Ravenscroft chris#voilaweb.com
14
15 Version 0.9
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 // CFR: Active Records Definitions
23 define('ADODB_JOIN_AR', 0x01);
24 define('ADODB_WORK_AR', 0x02);
25 define('ADODB_LAZY_AR', 0x03);
26
27
28 global $_ADODB_ACTIVE_DBS;
29 global $ADODB_ACTIVE_CACHESECS; // set to true to enable caching of metadata such as field info
30 global $ACTIVE_RECORD_SAFETY; // set to false to disable safety checks
31 global $ADODB_ACTIVE_DEFVALS; // use default values of table definition when creating new active record.
32
33 // array of ADODB_Active_DB's, indexed by ADODB_Active_Record->_dbat
34 $_ADODB_ACTIVE_DBS = array();
35 $ACTIVE_RECORD_SAFETY = true; // CFR: disabled while playing with relations
36 $ADODB_ACTIVE_DEFVALS = false;
37
38 class ADODB_Active_DB {
39 var $db; // ADOConnection
40 var $tables; // assoc array of ADODB_Active_Table objects, indexed by tablename
41 }
42
43 class ADODB_Active_Table {
44 var $name; // table name
45 var $flds; // assoc array of adofieldobjs, indexed by fieldname
46 var $keys; // assoc array of primary keys, indexed by fieldname
47 var $_created; // only used when stored as a cached file
48 var $_belongsTo = array();
49 var $_hasMany = array();
50 var $_colsCount; // total columns count, including relations
51
52 function updateColsCount()
53 {
54 $this->_colsCount = sizeof($this->flds);
55 foreach($this->_belongsTo as $foreignTable)
56 $this->_colsCount += sizeof($foreignTable->TableInfo()->flds);
57 foreach($this->_hasMany as $foreignTable)
58 $this->_colsCount += sizeof($foreignTable->TableInfo()->flds);
59 }
60 }
61
62 // returns index into $_ADODB_ACTIVE_DBS
63 function ADODB_SetDatabaseAdapter(&$db)
64 {
65 global $_ADODB_ACTIVE_DBS;
66
67 foreach($_ADODB_ACTIVE_DBS as $k => $d) {
68 if (PHP_VERSION >= 5) {
69 if ($d->db === $db) return $k;
70 } else {
71 if ($d->db->_connectionID === $db->_connectionID && $db->database == $d->db->database)
72 return $k;
73 }
74 }
75
76 $obj = new ADODB_Active_DB();
77 $obj->db = $db;
78 $obj->tables = array();
79
80 $_ADODB_ACTIVE_DBS[] = $obj;
81
82 return sizeof($_ADODB_ACTIVE_DBS)-1;
83 }
84
85
86 class ADODB_Active_Record {
87 static $_changeNames = true; // dynamically pluralize table names
88 static $_foreignSuffix = '_id'; //
89 var $_dbat; // associative index pointing to ADODB_Active_DB eg. $ADODB_Active_DBS[_dbat]
90 var $_table; // tablename, if set in class definition then use it as table name
91 var $_sTable; // singularized table name
92 var $_pTable; // pluralized table name
93 var $_tableat; // associative index pointing to ADODB_Active_Table, eg $ADODB_Active_DBS[_dbat]->tables[$this->_tableat]
94 var $_where; // where clause set in Load()
95 var $_saved = false; // indicates whether data is already inserted.
96 var $_lasterr = false; // last error message
97 var $_original = false; // the original values loaded or inserted, refreshed on update
98
99 var $foreignName; // CFR: class name when in a relationship
100
101 static function UseDefaultValues($bool=null)
102 {
103 global $ADODB_ACTIVE_DEFVALS;
104 if (isset($bool)) $ADODB_ACTIVE_DEFVALS = $bool;
105 return $ADODB_ACTIVE_DEFVALS;
106 }
107
108 // should be static
109 static function SetDatabaseAdapter(&$db)
110 {
111 return ADODB_SetDatabaseAdapter($db);
112 }
113
114
115 public function __set($name, $value)
116 {
117 $name = str_replace(' ', '_', $name);
118 $this->$name = $value;
119 }
120
121 // php5 constructor
122 // Note: if $table is defined, then we will use it as our table name
123 // Otherwise we will use our classname...
124 // In our database, table names are pluralized (because there can be
125 // more than one row!)
126 // Similarly, if $table is defined here, it has to be plural form.
127 //
128 // $options is an array that allows us to tweak the constructor's behaviour
129 // if $options['refresh'] is true, we re-scan our metadata information
130 // if $options['new'] is true, we forget all relations
131 function __construct($table = false, $pkeyarr=false, $db=false, $options=array())
132 {
133 global $ADODB_ASSOC_CASE,$_ADODB_ACTIVE_DBS;
134
135 if ($db == false && is_object($pkeyarr)) {
136 $db = $pkeyarr;
137 $pkeyarr = false;
138 }
139
140 if($table)
141 {
142 // table argument exists. It is expected to be
143 // already plural form.
144 $this->_pTable = $table;
145 $this->_sTable = $this->_singularize($this->_pTable);
146 }
147 else
148 {
149 // We will use current classname as table name.
150 // We need to pluralize it for the real table name.
151 $this->_sTable = strtolower(get_class($this));
152 $this->_pTable = $this->_pluralize($this->_sTable);
153 }
154 $this->_table = &$this->_pTable;
155
156 $this->foreignName = $this->_sTable; // CFR: default foreign name (singular)
157
158 if ($db) {
159 $this->_dbat = ADODB_Active_Record::SetDatabaseAdapter($db);
160 } else
161 $this->_dbat = sizeof($_ADODB_ACTIVE_DBS)-1;
162
163
164 if ($this->_dbat < 0) $this->Error("No database connection set; use ADOdb_Active_Record::SetDatabaseAdapter(\$db)",'ADODB_Active_Record::__constructor');
165
166 $this->_tableat = $this->_table; # reserved for setting the assoc value to a non-table name, eg. the sql string in future
167
168 // CFR: Just added this option because UpdateActiveTable() can refresh its information
169 // but there was no way to ask it to do that.
170 $forceUpdate = (isset($options['refresh']) && true === $options['refresh']);
171 $this->UpdateActiveTable($pkeyarr, $forceUpdate);
172 if(isset($options['new']) && true === $options['new'])
173 {
174 $table =& $this->TableInfo();
175 unset($table->_hasMany);
176 unset($table->_belongsTo);
177 $table->_hasMany = array();
178 $table->_belongsTo = array();
179 }
180 }
181
182 function __wakeup()
183 {
184 $class = get_class($this);
185 new $class;
186 }
187
188 // CFR: Constants found in Rails
189 static $IrregularP = array(
190 'PERSON' => 'people',
191 'MAN' => 'men',
192 'WOMAN' => 'women',
193 'CHILD' => 'children',
194 'COW' => 'kine',
195 );
196
197 static $IrregularS = array(
198 'PEOPLE' => 'PERSON',
199 'MEN' => 'man',
200 'WOMEN' => 'woman',
201 'CHILDREN' => 'child',
202 'KINE' => 'cow',
203 );
204
205 static $WeIsI = array(
206 'EQUIPMENT' => true,
207 'INFORMATION' => true,
208 'RICE' => true,
209 'MONEY' => true,
210 'SPECIES' => true,
211 'SERIES' => true,
212 'FISH' => true,
213 'SHEEP' => true,
214 );
215
216 function _pluralize($table)
217 {
218 if (!ADODB_Active_Record::$_changeNames) return $table;
219
220 $ut = strtoupper($table);
221 if(isset(self::$WeIsI[$ut]))
222 {
223 return $table;
224 }
225 if(isset(self::$IrregularP[$ut]))
226 {
227 return self::$IrregularP[$ut];
228 }
229 $len = strlen($table);
230 $lastc = $ut[$len-1];
231 $lastc2 = substr($ut,$len-2);
232 switch ($lastc) {
233 case 'S':
234 return $table.'es';
235 case 'Y':
236 return substr($table,0,$len-1).'ies';
237 case 'X':
238 return $table.'es';
239 case 'H':
240 if ($lastc2 == 'CH' || $lastc2 == 'SH')
241 return $table.'es';
242 default:
243 return $table.'s';
244 }
245 }
246
247 // CFR Lamest singular inflector ever - @todo Make it real!
248 // Note: There is an assumption here...and it is that the argument's length >= 4
249 function _singularize($table)
250 {
251
252 if (!ADODB_Active_Record::$_changeNames) return $table;
253
254 $ut = strtoupper($table);
255 if(isset(self::$WeIsI[$ut]))
256 {
257 return $table;
258 }
259 if(isset(self::$IrregularS[$ut]))
260 {
261 return self::$IrregularS[$ut];
262 }
263 $len = strlen($table);
264 if($ut[$len-1] != 'S')
265 return $table; // I know...forget oxen
266 if($ut[$len-2] != 'E')
267 return substr($table, 0, $len-1);
268 switch($ut[$len-3])
269 {
270 case 'S':
271 case 'X':
272 return substr($table, 0, $len-2);
273 case 'I':
274 return substr($table, 0, $len-3) . 'y';
275 case 'H';
276 if($ut[$len-4] == 'C' || $ut[$len-4] == 'S')
277 return substr($table, 0, $len-2);
278 default:
279 return substr($table, 0, $len-1); // ?
280 }
281 }
282
283 /*
284 * ar->foreignName will contain the name of the tables associated with this table because
285 * these other tables' rows may also be referenced by this table using theirname_id or the provided
286 * foreign keys (this index name is stored in ar->foreignKey)
287 *
288 * this-table.id = other-table-#1.this-table_id
289 * = other-table-#2.this-table_id
290 */
291 function hasMany($foreignRef,$foreignKey=false)
292 {
293 $ar = new ADODB_Active_Record($foreignRef);
294 $ar->foreignName = $foreignRef;
295 $ar->UpdateActiveTable();
296 $ar->foreignKey = ($foreignKey) ? $foreignKey : strtolower(get_class($this)) . self::$_foreignSuffix;
297
298 $table =& $this->TableInfo();
299 if(!isset($table->_hasMany[$foreignRef]))
300 {
301 $table->_hasMany[$foreignRef] = $ar;
302 $table->updateColsCount();
303 }
304 # @todo Can I make this guy be lazy?
305 $this->$foreignRef = $table->_hasMany[$foreignRef]; // WATCHME Removed assignment by ref. to please __get()
306 }
307
308 /**
309 * ar->foreignName will contain the name of the tables associated with this table because
310 * this table's rows may also be referenced by those tables using thistable_id or the provided
311 * foreign keys (this index name is stored in ar->foreignKey)
312 *
313 * this-table.other-table_id = other-table.id
314 */
315 function belongsTo($foreignRef,$foreignKey=false)
316 {
317 global $inflector;
318
319 $ar = new ADODB_Active_Record($this->_pluralize($foreignRef));
320 $ar->foreignName = $foreignRef;
321 $ar->UpdateActiveTable();
322 $ar->foreignKey = ($foreignKey) ? $foreignKey : $ar->foreignName . self::$_foreignSuffix;
323
324 $table =& $this->TableInfo();
325 if(!isset($table->_belongsTo[$foreignRef]))
326 {
327 $table->_belongsTo[$foreignRef] = $ar;
328 $table->updateColsCount();
329 }
330 $this->$foreignRef = $table->_belongsTo[$foreignRef];
331 }
332
333 /**
334 * __get Access properties - used for lazy loading
335 *
336 * @param mixed $name
337 * @access protected
338 * @return void
339 */
340 function __get($name)
341 {
342 return $this->LoadRelations($name, '', -1. -1);
343 }
344
345 function LoadRelations($name, $whereOrderBy, $offset=-1, $limit=-1)
346 {
347 $extras = array();
348 if($offset >= 0) $extras['offset'] = $offset;
349 if($limit >= 0) $extras['limit'] = $limit;
350 $table =& $this->TableInfo();
351
352 if (strlen($whereOrderBy))
353 if (!preg_match('/^[ \n\r]*AND/i',$whereOrderBy))
354 if (!preg_match('/^[ \n\r]*ORDER[ \n\r]/i',$whereOrderBy))
355 $whereOrderBy = 'AND '.$whereOrderBy;
356
357 if(!empty($table->_belongsTo[$name]))
358 {
359 $obj = $table->_belongsTo[$name];
360 $columnName = $obj->foreignKey;
361 if(empty($this->$columnName))
362 $this->$name = null;
363 else
364 {
365 if(($k = reset($obj->TableInfo()->keys)))
366 $belongsToId = $k;
367 else
368 $belongsToId = 'id';
369
370 $arrayOfOne =
371 $obj->Find(
372 $belongsToId.'='.$this->$columnName.' '.$whereOrderBy, false, false, $extras);
373 $this->$name = $arrayOfOne[0];
374 }
375 return $this->$name;
376 }
377 if(!empty($table->_hasMany[$name]))
378 {
379 $obj = $table->_hasMany[$name];
380 if(($k = reset($table->keys)))
381 $hasManyId = $k;
382 else
383 $hasManyId = 'id';
384
385 $this->$name =
386 $obj->Find(
387 $obj->foreignKey.'='.$this->$hasManyId.' '.$whereOrderBy, false, false, $extras);
388 return $this->$name;
389 }
390 }
391 //////////////////////////////////
392
393 // update metadata
394 function UpdateActiveTable($pkeys=false,$forceUpdate=false)
395 {
396 global $ADODB_ASSOC_CASE,$_ADODB_ACTIVE_DBS , $ADODB_CACHE_DIR, $ADODB_ACTIVE_CACHESECS;
397 global $ADODB_ACTIVE_DEFVALS, $ADODB_FETCH_MODE;
398
399 $activedb = $_ADODB_ACTIVE_DBS[$this->_dbat];
400
401 $table = $this->_table;
402 $tables = $activedb->tables;
403 $tableat = $this->_tableat;
404 if (!$forceUpdate && !empty($tables[$tableat])) {
405
406 $tobj = $tables[$tableat];
407 foreach($tobj->flds as $name => $fld) {
408 if ($ADODB_ACTIVE_DEFVALS && isset($fld->default_value))
409 $this->$name = $fld->default_value;
410 else
411 $this->$name = null;
412 }
413 return;
414 }
415
416 $db = $activedb->db;
417 $fname = $ADODB_CACHE_DIR . '/adodb_' . $db->databaseType . '_active_'. $table . '.cache';
418 if (!$forceUpdate && $ADODB_ACTIVE_CACHESECS && $ADODB_CACHE_DIR && file_exists($fname)) {
419 $fp = fopen($fname,'r');
420 @flock($fp, LOCK_SH);
421 $acttab = unserialize(fread($fp,100000));
422 fclose($fp);
423 if ($acttab->_created + $ADODB_ACTIVE_CACHESECS - (abs(rand()) % 16) > time()) {
424 // abs(rand()) randomizes deletion, reducing contention to delete/refresh file
425 // ideally, you should cache at least 32 secs
426 $activedb->tables[$table] = $acttab;
427
428 //if ($db->debug) ADOConnection::outp("Reading cached active record file: $fname");
429 return;
430 } else if ($db->debug) {
431 ADOConnection::outp("Refreshing cached active record file: $fname");
432 }
433 }
434 $activetab = new ADODB_Active_Table();
435 $activetab->name = $table;
436
437 $save = $ADODB_FETCH_MODE;
438 $ADODB_FETCH_MODE = ADODB_FETCH_ASSOC;
439 if ($db->fetchMode !== false) $savem = $db->SetFetchMode(false);
440
441 $cols = $db->MetaColumns($table);
442
443 if (isset($savem)) $db->SetFetchMode($savem);
444 $ADODB_FETCH_MODE = $save;
445
446 if (!$cols) {
447 $this->Error("Invalid table name: $table",'UpdateActiveTable');
448 return false;
449 }
450 $fld = reset($cols);
451 if (!$pkeys) {
452 if (isset($fld->primary_key)) {
453 $pkeys = array();
454 foreach($cols as $name => $fld) {
455 if (!empty($fld->primary_key)) $pkeys[] = $name;
456 }
457 } else
458 $pkeys = $this->GetPrimaryKeys($db, $table);
459 }
460 if (empty($pkeys)) {
461 $this->Error("No primary key found for table $table",'UpdateActiveTable');
462 return false;
463 }
464
465 $attr = array();
466 $keys = array();
467
468 switch($ADODB_ASSOC_CASE) {
469 case 0:
470 foreach($cols as $name => $fldobj) {
471 $name = strtolower($name);
472 if ($ADODB_ACTIVE_DEFVALS && isset($fldobj->default_value))
473 $this->$name = $fldobj->default_value;
474 else
475 $this->$name = null;
476 $attr[$name] = $fldobj;
477 }
478 foreach($pkeys as $k => $name) {
479 $keys[strtolower($name)] = strtolower($name);
480 }
481 break;
482
483 case 1:
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 else
490 $this->$name = null;
491 $attr[$name] = $fldobj;
492 }
493
494 foreach($pkeys as $k => $name) {
495 $keys[strtoupper($name)] = strtoupper($name);
496 }
497 break;
498 default:
499 foreach($cols as $name => $fldobj) {
500 $name = ($fldobj->name);
501
502 if ($ADODB_ACTIVE_DEFVALS && isset($fldobj->default_value))
503 $this->$name = $fldobj->default_value;
504 else
505 $this->$name = null;
506 $attr[$name] = $fldobj;
507 }
508 foreach($pkeys as $k => $name) {
509 $keys[$name] = $cols[$name]->name;
510 }
511 break;
512 }
513
514 $activetab->keys = $keys;
515 $activetab->flds = $attr;
516 $activetab->updateColsCount();
517
518 if ($ADODB_ACTIVE_CACHESECS && $ADODB_CACHE_DIR) {
519 $activetab->_created = time();
520 $s = serialize($activetab);
521 if (!function_exists('adodb_write_file')) include(ADODB_DIR.'/adodb-csvlib.inc.php');
522 adodb_write_file($fname,$s);
523 }
524 if (isset($activedb->tables[$table])) {
525 $oldtab = $activedb->tables[$table];
526
527 if ($oldtab) $activetab->_belongsTo = $oldtab->_belongsTo;
528 if ($oldtab) $activetab->_hasMany = $oldtab->_hasMany;
529 }
530 $activedb->tables[$table] = $activetab;
531 }
532
533 function GetPrimaryKeys(&$db, $table)
534 {
535 return $db->MetaPrimaryKeys($table);
536 }
537
538 // error handler for both PHP4+5.
539 function Error($err,$fn)
540 {
541 global $_ADODB_ACTIVE_DBS;
542
543 $fn = get_class($this).'::'.$fn;
544 $this->_lasterr = $fn.': '.$err;
545
546 if ($this->_dbat < 0) $db = false;
547 else {
548 $activedb = $_ADODB_ACTIVE_DBS[$this->_dbat];
549 $db = $activedb->db;
550 }
551
552 if (function_exists('adodb_throw')) {
553 if (!$db) adodb_throw('ADOdb_Active_Record', $fn, -1, $err, 0, 0, false);
554 else adodb_throw($db->databaseType, $fn, -1, $err, 0, 0, $db);
555 } else
556 if (!$db || $db->debug) ADOConnection::outp($this->_lasterr);
557
558 }
559
560 // return last error message
561 function ErrorMsg()
562 {
563 if (!function_exists('adodb_throw')) {
564 if ($this->_dbat < 0) $db = false;
565 else $db = $this->DB();
566
567 // last error could be database error too
568 if ($db && $db->ErrorMsg()) return $db->ErrorMsg();
569 }
570 return $this->_lasterr;
571 }
572
573 function ErrorNo()
574 {
575 if ($this->_dbat < 0) return -9999; // no database connection...
576 $db = $this->DB();
577
578 return (int) $db->ErrorNo();
579 }
580
581
582 // retrieve ADOConnection from _ADODB_Active_DBs
583 function DB()
584 {
585 global $_ADODB_ACTIVE_DBS;
586
587 if ($this->_dbat < 0) {
588 $false = false;
589 $this->Error("No database connection set: use ADOdb_Active_Record::SetDatabaseAdaptor(\$db)", "DB");
590 return $false;
591 }
592 $activedb = $_ADODB_ACTIVE_DBS[$this->_dbat];
593 $db = $activedb->db;
594 return $db;
595 }
596
597 // retrieve ADODB_Active_Table
598 function &TableInfo()
599 {
600 global $_ADODB_ACTIVE_DBS;
601
602 $activedb = $_ADODB_ACTIVE_DBS[$this->_dbat];
603 $table = $activedb->tables[$this->_tableat];
604 return $table;
605 }
606
607
608 // I have an ON INSERT trigger on a table that sets other columns in the table.
609 // So, I find that for myTable, I want to reload an active record after saving it. -- Malcolm Cook
610 function Reload()
611 {
612 $db =& $this->DB(); if (!$db) return false;
613 $table =& $this->TableInfo();
614 $where = $this->GenWhere($db, $table);
615 return($this->Load($where));
616 }
617
618
619 // set a numeric array (using natural table field ordering) as object properties
620 function Set(&$row)
621 {
622 global $ACTIVE_RECORD_SAFETY;
623
624 $db = $this->DB();
625
626 if (!$row) {
627 $this->_saved = false;
628 return false;
629 }
630
631 $this->_saved = true;
632
633 $table = $this->TableInfo();
634 $sizeofFlds = sizeof($table->flds);
635 $sizeofRow = sizeof($row);
636 if ($ACTIVE_RECORD_SAFETY && $table->_colsCount != $sizeofRow && $sizeofFlds != $sizeofRow) {
637 # <AP>
638 $bad_size = TRUE;
639 if($sizeofRow == 2 * $table->_colsCount || $sizeofRow == 2 * $sizeofFlds) {
640 // Only keep string keys
641 $keys = array_filter(array_keys($row), 'is_string');
642 if (sizeof($keys) == sizeof($table->flds))
643 $bad_size = FALSE;
644 }
645 if ($bad_size) {
646 $this->Error("Table structure of $this->_table has changed","Load");
647 return false;
648 }
649 # </AP>
650 }
651 else
652 $keys = array_keys($row);
653 # <AP>
654 reset($keys);
655 $this->_original = array();
656 foreach($table->flds as $name=>$fld)
657 {
658 $value = $row[current($keys)];
659 $this->$name = $value;
660 $this->_original[] = $value;
661 if(!next($keys)) break;
662 }
663 $table =& $this->TableInfo();
664 foreach($table->_belongsTo as $foreignTable)
665 {
666 $ft = $foreignTable->TableInfo();
667 $propertyName = $ft->name;
668 foreach($ft->flds as $name=>$fld)
669 {
670 $value = $row[current($keys)];
671 $foreignTable->$name = $value;
672 $foreignTable->_original[] = $value;
673 if(!next($keys)) break;
674 }
675 }
676 foreach($table->_hasMany as $foreignTable)
677 {
678 $ft = $foreignTable->TableInfo();
679 foreach($ft->flds as $name=>$fld)
680 {
681 $value = $row[current($keys)];
682 $foreignTable->$name = $value;
683 $foreignTable->_original[] = $value;
684 if(!next($keys)) break;
685 }
686 }
687 # </AP>
688 return true;
689 }
690
691 // get last inserted id for INSERT
692 function LastInsertID(&$db,$fieldname)
693 {
694 if ($db->hasInsertID)
695 $val = $db->Insert_ID($this->_table,$fieldname);
696 else
697 $val = false;
698
699 if (is_null($val) || $val === false) {
700 // this might not work reliably in multi-user environment
701 return $db->GetOne("select max(".$fieldname.") from ".$this->_table);
702 }
703 return $val;
704 }
705
706 // quote data in where clause
707 function doquote(&$db, $val,$t)
708 {
709 switch($t) {
710 case 'D':
711 case 'T':
712 if (empty($val)) return 'null';
713
714 case 'C':
715 case 'X':
716 if (is_null($val)) return 'null';
717
718 if (strlen($val)>1 &&
719 (strncmp($val,"'",1) != 0 || substr($val,strlen($val)-1,1) != "'")) {
720 return $db->qstr($val);
721 break;
722 }
723 default:
724 return $val;
725 break;
726 }
727 }
728
729 // generate where clause for an UPDATE/SELECT
730 function GenWhere(&$db, &$table)
731 {
732 $keys = $table->keys;
733 $parr = array();
734
735 foreach($keys as $k) {
736 $f = $table->flds[$k];
737 if ($f) {
738 $parr[] = $k.' = '.$this->doquote($db,$this->$k,$db->MetaType($f->type));
739 }
740 }
741 return implode(' and ', $parr);
742 }
743
744
745 //------------------------------------------------------------ Public functions below
746
747 function Load($where=null,$bindarr=false)
748 {
749 $db = $this->DB(); if (!$db) return false;
750 $this->_where = $where;
751
752 $save = $db->SetFetchMode(ADODB_FETCH_NUM);
753 $qry = "select * from ".$this->_table;
754 $table =& $this->TableInfo();
755
756 if(($k = reset($table->keys)))
757 $hasManyId = $k;
758 else
759 $hasManyId = 'id';
760
761 foreach($table->_belongsTo as $foreignTable)
762 {
763 if(($k = reset($foreignTable->TableInfo()->keys)))
764 {
765 $belongsToId = $k;
766 }
767 else
768 {
769 $belongsToId = 'id';
770 }
771 $qry .= ' LEFT JOIN '.$foreignTable->_table.' ON '.
772 $this->_table.'.'.$foreignTable->foreignKey.'='.
773 $foreignTable->_table.'.'.$belongsToId;
774 }
775 foreach($table->_hasMany as $foreignTable)
776 {
777 $qry .= ' LEFT JOIN '.$foreignTable->_table.' ON '.
778 $this->_table.'.'.$hasManyId.'='.
779 $foreignTable->_table.'.'.$foreignTable->foreignKey;
780 }
781 if($where)
782 $qry .= ' WHERE '.$where;
783
784 // Simple case: no relations. Load row and return.
785 if((count($table->_hasMany) + count($table->_belongsTo)) < 1)
786 {
787 $row = $db->GetRow($qry,$bindarr);
788 if(!$row)
789 return false;
790 $db->SetFetchMode($save);
791 return $this->Set($row);
792 }
793
794 // More complex case when relations have to be collated
795 $rows = $db->GetAll($qry,$bindarr);
796 if(!$rows)
797 return false;
798 $db->SetFetchMode($save);
799 if(count($rows) < 1)
800 return false;
801 $class = get_class($this);
802 $isFirstRow = true;
803
804 if(($k = reset($this->TableInfo()->keys)))
805 $myId = $k;
806 else
807 $myId = 'id';
808 $index = 0; $found = false;
809 /** @todo Improve by storing once and for all in table metadata */
810 /** @todo Also re-use info for hasManyId */
811 foreach($this->TableInfo()->flds as $fld)
812 {
813 if($fld->name == $myId)
814 {
815 $found = true;
816 break;
817 }
818 $index++;
819 }
820 if(!$found)
821 $this->outp_throw("Unable to locate key $myId for $class in Load()",'Load');
822
823 foreach($rows as $row)
824 {
825 $rowId = intval($row[$index]);
826 if($rowId > 0)
827 {
828 if($isFirstRow)
829 {
830 $isFirstRow = false;
831 if(!$this->Set($row))
832 return false;
833 }
834 $obj = new $class($table,false,$db);
835 $obj->Set($row);
836 // TODO Copy/paste code below: bad!
837 if(count($table->_hasMany) > 0)
838 {
839 foreach($table->_hasMany as $foreignTable)
840 {
841 $foreignName = $foreignTable->foreignName;
842 if(!empty($obj->$foreignName))
843 {
844 if(!is_array($this->$foreignName))
845 {
846 $foreignObj = $this->$foreignName;
847 $this->$foreignName = array(clone($foreignObj));
848 }
849 else
850 {
851 $foreignObj = $obj->$foreignName;
852 array_push($this->$foreignName, clone($foreignObj));
853 }
854 }
855 }
856 }
857 if(count($table->_belongsTo) > 0)
858 {
859 foreach($table->_belongsTo as $foreignTable)
860 {
861 $foreignName = $foreignTable->foreignName;
862 if(!empty($obj->$foreignName))
863 {
864 if(!is_array($this->$foreignName))
865 {
866 $foreignObj = $this->$foreignName;
867 $this->$foreignName = array(clone($foreignObj));
868 }
869 else
870 {
871 $foreignObj = $obj->$foreignName;
872 array_push($this->$foreignName, clone($foreignObj));
873 }
874 }
875 }
876 }
877 }
878 }
879 return true;
880 }
881
882 // false on error
883 function Save()
884 {
885 if ($this->_saved) $ok = $this->Update();
886 else $ok = $this->Insert();
887
888 return $ok;
889 }
890
891 // CFR: Sometimes we may wish to consider that an object is not to be replaced but inserted.
892 // Sample use case: an 'undo' command object (after a delete())
893 function Dirty()
894 {
895 $this->_saved = false;
896 }
897
898 // false on error
899 function Insert()
900 {
901 $db = $this->DB(); if (!$db) return false;
902 $cnt = 0;
903 $table = $this->TableInfo();
904
905 $valarr = array();
906 $names = array();
907 $valstr = array();
908
909 foreach($table->flds as $name=>$fld) {
910 $val = $this->$name;
911 if(!is_null($val) || !array_key_exists($name, $table->keys)) {
912 $valarr[] = $val;
913 $names[] = $name;
914 $valstr[] = $db->Param($cnt);
915 $cnt += 1;
916 }
917 }
918
919 if (empty($names)){
920 foreach($table->flds as $name=>$fld) {
921 $valarr[] = null;
922 $names[] = $name;
923 $valstr[] = $db->Param($cnt);
924 $cnt += 1;
925 }
926 }
927 $sql = 'INSERT INTO '.$this->_table."(".implode(',',$names).') VALUES ('.implode(',',$valstr).')';
928 $ok = $db->Execute($sql,$valarr);
929
930 if ($ok) {
931 $this->_saved = true;
932 $autoinc = false;
933 foreach($table->keys as $k) {
934 if (is_null($this->$k)) {
935 $autoinc = true;
936 break;
937 }
938 }
939 if ($autoinc && sizeof($table->keys) == 1) {
940 $k = reset($table->keys);
941 $this->$k = $this->LastInsertID($db,$k);
942 }
943 }
944
945 $this->_original = $valarr;
946 return !empty($ok);
947 }
948
949 function Delete()
950 {
951 $db = $this->DB(); if (!$db) return false;
952 $table = $this->TableInfo();
953
954 $where = $this->GenWhere($db,$table);
955 $sql = 'DELETE FROM '.$this->_table.' WHERE '.$where;
956 $ok = $db->Execute($sql);
957
958 return $ok ? true : false;
959 }
960
961 // returns an array of active record objects
962 function Find($whereOrderBy,$bindarr=false,$pkeysArr=false,$extra=array())
963 {
964 $db = $this->DB(); if (!$db || empty($this->_table)) return false;
965 $table =& $this->TableInfo();
966 $arr = $db->GetActiveRecordsClass(get_class($this),$this, $whereOrderBy,$bindarr,$pkeysArr,$extra,
967 array('foreignName'=>$this->foreignName, 'belongsTo'=>$table->_belongsTo, 'hasMany'=>$table->_hasMany));
968 return $arr;
969 }
970
971 // CFR: In introduced this method to ensure that inner workings are not disturbed by
972 // subclasses...for instance when GetActiveRecordsClass invokes Find()
973 // Why am I not invoking parent::Find?
974 // Shockingly because I want to preserve PHP4 compatibility.
975 function packageFind($whereOrderBy,$bindarr=false,$pkeysArr=false,$extra=array())
976 {
977 $db = $this->DB(); if (!$db || empty($this->_table)) return false;
978 $table =& $this->TableInfo();
979 $arr = $db->GetActiveRecordsClass(get_class($this),$this, $whereOrderBy,$bindarr,$pkeysArr,$extra,
980 array('foreignName'=>$this->foreignName, 'belongsTo'=>$table->_belongsTo, 'hasMany'=>$table->_hasMany));
981 return $arr;
982 }
983
984 // returns 0 on error, 1 on update, 2 on insert
985 function Replace()
986 {
987 global $ADODB_ASSOC_CASE;
988
989 $db = $this->DB(); if (!$db) return false;
990 $table = $this->TableInfo();
991
992 $pkey = $table->keys;
993
994 foreach($table->flds as $name=>$fld) {
995 $val = $this->$name;
996 /*
997 if (is_null($val)) {
998 if (isset($fld->not_null) && $fld->not_null) {
999 if (isset($fld->default_value) && strlen($fld->default_value)) continue;
1000 else {
1001 $this->Error("Cannot update null into $name","Replace");
1002 return false;
1003 }
1004 }
1005 }*/
1006 if (is_null($val) && !empty($fld->auto_increment)) {
1007 continue;
1008 }
1009 $t = $db->MetaType($fld->type);
1010 $arr[$name] = $this->doquote($db,$val,$t);
1011 $valarr[] = $val;
1012 }
1013
1014 if (!is_array($pkey)) $pkey = array($pkey);
1015
1016
1017 if ($ADODB_ASSOC_CASE == 0)
1018 foreach($pkey as $k => $v)
1019 $pkey[$k] = strtolower($v);
1020 elseif ($ADODB_ASSOC_CASE == 1)
1021 foreach($pkey as $k => $v)
1022 $pkey[$k] = strtoupper($v);
1023
1024 $ok = $db->Replace($this->_table,$arr,$pkey);
1025 if ($ok) {
1026 $this->_saved = true; // 1= update 2=insert
1027 if ($ok == 2) {
1028 $autoinc = false;
1029 foreach($table->keys as $k) {
1030 if (is_null($this->$k)) {
1031 $autoinc = true;
1032 break;
1033 }
1034 }
1035 if ($autoinc && sizeof($table->keys) == 1) {
1036 $k = reset($table->keys);
1037 $this->$k = $this->LastInsertID($db,$k);
1038 }
1039 }
1040
1041 $this->_original = $valarr;
1042 }
1043 return $ok;
1044 }
1045
1046 // returns 0 on error, 1 on update, -1 if no change in data (no update)
1047 function Update()
1048 {
1049 $db = $this->DB(); if (!$db) return false;
1050 $table = $this->TableInfo();
1051
1052 $where = $this->GenWhere($db, $table);
1053
1054 if (!$where) {
1055 $this->error("Where missing for table $table", "Update");
1056 return false;
1057 }
1058 $valarr = array();
1059 $neworig = array();
1060 $pairs = array();
1061 $i = -1;
1062 $cnt = 0;
1063 foreach($table->flds as $name=>$fld) {
1064 $i += 1;
1065 $val = $this->$name;
1066 $neworig[] = $val;
1067
1068 if (isset($table->keys[$name])) {
1069 continue;
1070 }
1071
1072 if (is_null($val)) {
1073 if (isset($fld->not_null) && $fld->not_null) {
1074 if (isset($fld->default_value) && strlen($fld->default_value)) continue;
1075 else {
1076 $this->Error("Cannot set field $name to NULL","Update");
1077 return false;
1078 }
1079 }
1080 }
1081
1082 if (isset($this->_original[$i]) && $val == $this->_original[$i]) {
1083 continue;
1084 }
1085 $valarr[] = $val;
1086 $pairs[] = $name.'='.$db->Param($cnt);
1087 $cnt += 1;
1088 }
1089
1090
1091 if (!$cnt) return -1;
1092 $sql = 'UPDATE '.$this->_table." SET ".implode(",",$pairs)." WHERE ".$where;
1093 $ok = $db->Execute($sql,$valarr);
1094 if ($ok) {
1095 $this->_original = $neworig;
1096 return 1;
1097 }
1098 return 0;
1099 }
1100
1101 function GetAttributeNames()
1102 {
1103 $table = $this->TableInfo();
1104 if (!$table) return false;
1105 return array_keys($table->flds);
1106 }
1107
1108 };
1109
1110 function adodb_GetActiveRecordsClass(&$db, $class, $tableObj,$whereOrderBy,$bindarr, $primkeyArr,
1111 $extra, $relations)
1112 {
1113 global $_ADODB_ACTIVE_DBS;
1114
1115 if (empty($extra['loading'])) $extra['loading'] = ADODB_LAZY_AR;
1116
1117 $save = $db->SetFetchMode(ADODB_FETCH_NUM);
1118 $table = &$tableObj->_table;
1119 $tableInfo =& $tableObj->TableInfo();
1120 if(($k = reset($tableInfo->keys)))
1121 $myId = $k;
1122 else
1123 $myId = 'id';
1124 $index = 0; $found = false;
1125 /** @todo Improve by storing once and for all in table metadata */
1126 /** @todo Also re-use info for hasManyId */
1127 foreach($tableInfo->flds as $fld)
1128 {
1129 if($fld->name == $myId)
1130 {
1131 $found = true;
1132 break;
1133 }
1134 $index++;
1135 }
1136 if(!$found)
1137 $db->outp_throw("Unable to locate key $myId for $class in GetActiveRecordsClass()",'GetActiveRecordsClass');
1138
1139 $qry = "select * from ".$table;
1140 if(ADODB_JOIN_AR == $extra['loading'])
1141 {
1142 if(!empty($relations['belongsTo']))
1143 {
1144 foreach($relations['belongsTo'] as $foreignTable)
1145 {
1146 if(($k = reset($foreignTable->TableInfo()->keys)))
1147 {
1148 $belongsToId = $k;
1149 }
1150 else
1151 {
1152 $belongsToId = 'id';
1153 }
1154
1155 $qry .= ' LEFT JOIN '.$foreignTable->_table.' ON '.
1156 $table.'.'.$foreignTable->foreignKey.'='.
1157 $foreignTable->_table.'.'.$belongsToId;
1158 }
1159 }
1160 if(!empty($relations['hasMany']))
1161 {
1162 if(empty($relations['foreignName']))
1163 $db->outp_throw("Missing foreignName is relation specification in GetActiveRecordsClass()",'GetActiveRecordsClass');
1164 if(($k = reset($tableInfo->keys)))
1165 $hasManyId = $k;
1166 else
1167 $hasManyId = 'id';
1168
1169 foreach($relations['hasMany'] as $foreignTable)
1170 {
1171 $qry .= ' LEFT JOIN '.$foreignTable->_table.' ON '.
1172 $table.'.'.$hasManyId.'='.
1173 $foreignTable->_table.'.'.$foreignTable->foreignKey;
1174 }
1175 }
1176 }
1177 if (!empty($whereOrderBy))
1178 $qry .= ' WHERE '.$whereOrderBy;
1179 if(isset($extra['limit']))
1180 {
1181 $rows = false;
1182 if(isset($extra['offset'])) {
1183 $rs = $db->SelectLimit($qry, $extra['limit'], $extra['offset']);
1184 } else {
1185 $rs = $db->SelectLimit($qry, $extra['limit']);
1186 }
1187 if ($rs) {
1188 while (!$rs->EOF) {
1189 $rows[] = $rs->fields;
1190 $rs->MoveNext();
1191 }
1192 }
1193 } else
1194 $rows = $db->GetAll($qry,$bindarr);
1195
1196 $db->SetFetchMode($save);
1197
1198 $false = false;
1199
1200 if ($rows === false) {
1201 return $false;
1202 }
1203
1204
1205 if (!isset($_ADODB_ACTIVE_DBS)) {
1206 include(ADODB_DIR.'/adodb-active-record.inc.php');
1207 }
1208 if (!class_exists($class)) {
1209 $db->outp_throw("Unknown class $class in GetActiveRecordsClass()",'GetActiveRecordsClass');
1210 return $false;
1211 }
1212 $uniqArr = array(); // CFR Keep track of records for relations
1213 $arr = array();
1214 // arrRef will be the structure that knows about our objects.
1215 // It is an associative array.
1216 // We will, however, return arr, preserving regular 0.. order so that
1217 // obj[0] can be used by app developpers.
1218 $arrRef = array();
1219 $bTos = array(); // Will store belongTo's indices if any
1220 foreach($rows as $row) {
1221
1222 $obj = new $class($table,$primkeyArr,$db);
1223 if ($obj->ErrorNo()){
1224 $db->_errorMsg = $obj->ErrorMsg();
1225 return $false;
1226 }
1227 $obj->Set($row);
1228 // CFR: FIXME: Insane assumption here:
1229 // If the first column returned is an integer, then it's a 'id' field
1230 // And to make things a bit worse, I use intval() rather than is_int() because, in fact,
1231 // $row[0] is not an integer.
1232 //
1233 // So, what does this whole block do?
1234 // When relationships are found, we perform JOINs. This is fast. But not accurate:
1235 // instead of returning n objects with their n' associated cousins,
1236 // we get n*n' objects. This code fixes this.
1237 // Note: to-many relationships mess around with the 'limit' parameter
1238 $rowId = intval($row[$index]);
1239
1240 if(ADODB_WORK_AR == $extra['loading'])
1241 {
1242 $arrRef[$rowId] = $obj;
1243 $arr[] = &$arrRef[$rowId];
1244 if(!isset($indices))
1245 $indices = $rowId;
1246 else
1247 $indices .= ','.$rowId;
1248 if(!empty($relations['belongsTo']))
1249 {
1250 foreach($relations['belongsTo'] as $foreignTable)
1251 {
1252 $foreignTableRef = $foreignTable->foreignKey;
1253 // First array: list of foreign ids we are looking for
1254 if(empty($bTos[$foreignTableRef]))
1255 $bTos[$foreignTableRef] = array();
1256 // Second array: list of ids found
1257 if(empty($obj->$foreignTableRef))
1258 continue;
1259 if(empty($bTos[$foreignTableRef][$obj->$foreignTableRef]))
1260 $bTos[$foreignTableRef][$obj->$foreignTableRef] = array();
1261 $bTos[$foreignTableRef][$obj->$foreignTableRef][] = $obj;
1262 }
1263 }
1264 continue;
1265 }
1266
1267 if($rowId>0)
1268 {
1269 if(ADODB_JOIN_AR == $extra['loading'])
1270 {
1271 $isNewObj = !isset($uniqArr['_'.$row[0]]);
1272 if($isNewObj)
1273 $uniqArr['_'.$row[0]] = $obj;
1274
1275 // TODO Copy/paste code below: bad!
1276 if(!empty($relations['hasMany']))
1277 {
1278 foreach($relations['hasMany'] as $foreignTable)
1279 {
1280 $foreignName = $foreignTable->foreignName;
1281 if(!empty($obj->$foreignName))
1282 {
1283 $masterObj = &$uniqArr['_'.$row[0]];
1284 // Assumption: this property exists in every object since they are instances of the same class
1285 if(!is_array($masterObj->$foreignName))
1286 {
1287 // Pluck!
1288 $foreignObj = $masterObj->$foreignName;
1289 $masterObj->$foreignName = array(clone($foreignObj));
1290 }
1291 else
1292 {
1293 // Pluck pluck!
1294 $foreignObj = $obj->$foreignName;
1295 array_push($masterObj->$foreignName, clone($foreignObj));
1296 }
1297 }
1298 }
1299 }
1300 if(!empty($relations['belongsTo']))
1301 {
1302 foreach($relations['belongsTo'] as $foreignTable)
1303 {
1304 $foreignName = $foreignTable->foreignName;
1305 if(!empty($obj->$foreignName))
1306 {
1307 $masterObj = &$uniqArr['_'.$row[0]];
1308 // Assumption: this property exists in every object since they are instances of the same class
1309 if(!is_array($masterObj->$foreignName))
1310 {
1311 // Pluck!
1312 $foreignObj = $masterObj->$foreignName;
1313 $masterObj->$foreignName = array(clone($foreignObj));
1314 }
1315 else
1316 {
1317 // Pluck pluck!
1318 $foreignObj = $obj->$foreignName;
1319 array_push($masterObj->$foreignName, clone($foreignObj));
1320 }
1321 }
1322 }
1323 }
1324 if(!$isNewObj)
1325 unset($obj); // We do not need this object itself anymore and do not want it re-added to the main array
1326 }
1327 else if(ADODB_LAZY_AR == $extra['loading'])
1328 {
1329 // Lazy loading: we need to give AdoDb a hint that we have not really loaded
1330 // anything, all the while keeping enough information on what we wish to load.
1331 // Let's do this by keeping the relevant info in our relationship arrays
1332 // but get rid of the actual properties.
1333 // We will then use PHP's __get to load these properties on-demand.
1334 if(!empty($relations['hasMany']))
1335 {
1336 foreach($relations['hasMany'] as $foreignTable)
1337 {
1338 $foreignName = $foreignTable->foreignName;
1339 if(!empty($obj->$foreignName))
1340 {
1341 unset($obj->$foreignName);
1342 }
1343 }
1344 }
1345 if(!empty($relations['belongsTo']))
1346 {
1347 foreach($relations['belongsTo'] as $foreignTable)
1348 {
1349 $foreignName = $foreignTable->foreignName;
1350 if(!empty($obj->$foreignName))
1351 {
1352 unset($obj->$foreignName);
1353 }
1354 }
1355 }
1356 }
1357 }
1358
1359 if(isset($obj))
1360 $arr[] = $obj;
1361 }
1362
1363 if(ADODB_WORK_AR == $extra['loading'])
1364 {
1365 // The best of both worlds?
1366 // Here, the number of queries is constant: 1 + n*relationship.
1367 // The second query will allow us to perform a good join
1368 // while preserving LIMIT etc.
1369 if(!empty($relations['hasMany']))
1370 {
1371 foreach($relations['hasMany'] as $foreignTable)
1372 {
1373 $foreignName = $foreignTable->foreignName;
1374 $className = ucfirst($foreignTable->_singularize($foreignName));
1375 $obj = new $className();
1376 $dbClassRef = $foreignTable->foreignKey;
1377 $objs = $obj->packageFind($dbClassRef.' IN ('.$indices.')');
1378 foreach($objs as $obj)
1379 {
1380 if(!is_array($arrRef[$obj->$dbClassRef]->$foreignName))
1381 $arrRef[$obj->$dbClassRef]->$foreignName = array();
1382 array_push($arrRef[$obj->$dbClassRef]->$foreignName, $obj);
1383 }
1384 }
1385
1386 }
1387 if(!empty($relations['belongsTo']))
1388 {
1389 foreach($relations['belongsTo'] as $foreignTable)
1390 {
1391 $foreignTableRef = $foreignTable->foreignKey;
1392 if(empty($bTos[$foreignTableRef]))
1393 continue;
1394 if(($k = reset($foreignTable->TableInfo()->keys)))
1395 {
1396 $belongsToId = $k;
1397 }
1398 else
1399 {
1400 $belongsToId = 'id';
1401 }
1402 $origObjsArr = $bTos[$foreignTableRef];
1403 $bTosString = implode(',', array_keys($bTos[$foreignTableRef]));
1404 $foreignName = $foreignTable->foreignName;
1405 $className = ucfirst($foreignTable->_singularize($foreignName));
1406 $obj = new $className();
1407 $objs = $obj->packageFind($belongsToId.' IN ('.$bTosString.')');
1408 foreach($objs as $obj)
1409 {
1410 foreach($origObjsArr[$obj->$belongsToId] as $idx=>$origObj)
1411 {
1412 $origObj->$foreignName = $obj;
1413 }
1414 }
1415 }
1416 }
1417 }
1418
1419 return $arr;
1420 }
1421 ?>
Mirror of official OpenEMR Sourceforge repository