Source/carbon/database/Database_active_record.php

   1 <?php
   2 /*------------------------------------------------------------
   3 *  CarbonPHP framework (C) Tom Bell
   4 *  http://tombell.org.uk
   5 *------------------------------------------------------------*/
   6
   7 if (!defined('CARBON_PATH'))
   8 {
   9         exit('Direct script access is not allowed.');
  10 }
  11
  12 class Carbon_Database_active_record extends Carbon_Database_driver
  13 {
  14         protected $ar_select = array();
  15         protected $ar_distinct = false;
  16         protected $ar_from = array();
  17         protected $ar_join = array();
  18         protected $ar_where = array();
  19         protected $ar_like = array();
  20         protected $ar_groupby = array();
  21         protected $ar_having = array();
  22         protected $ar_limit = false;
  23         protected $ar_offset = false;
  24         protected $ar_order = false;
  25         protected $ar_orderby = array();
  26         protected $ar_set = array();
  27         protected $ar_wherein = array();
  28         protected $ar_aliased_tables = array();
  29         protected $ar_store_array = array();
  30
  31         protected $ar_caching = false;
  32         protected $ar_cache_select = array();
  33         protected $ar_cache_from = array();
  34         protected $ar_cache_join = array();
  35         protected $ar_cache_where = array();
  36         protected $ar_cache_like = array();
  37         protected $ar_cache_groupby = array();
  38         protected $ar_cache_having = array();
  39         protected $ar_cache_limit = false;
  40         protected $ar_cache_offset = false;
  41         protected $ar_cache_order = false;
  42         protected $ar_cache_orderby = array();
  43         protected $ar_cache_set = array();
  44
  45         public function dbprefix($table = '')
  46         {
  47                 if ($table == '')
  48                 {
  49                         $this->display_error('database_table_name_required');
  50                 }
  51
  52                 return $this->dbprefix . $table;
  53         }
  54
  55         public function select($select = '*', $protected_identifiers = true)
  56         {
  57                 if (is_string($select))
  58                 {
  59                         $select = explode(', ', $select);
  60                 }
  61
  62                 foreach ($select as $value)
  63                 {
  64                         $value = trim($value);
  65
  66                         if ($value != '*' && $protected_identifiers !== false)
  67                         {
  68                                 if (strpos($value, '.') !== false)
  69                                 {
  70                                         $value = $this->dbprefix . $value;
  71                                 }
  72                                 else
  73                                 {
  74                                         $value = $this->database_protect_identifiers($value);
  75                                 }
  76                         }
  77
  78                         if ($value != '')
  79                         {
  80                                 $this->ar_select[] = $value;
  81
  82                                 if ($this->ar_caching === true)
  83                                 {
  84                                         $this->ar_cache_select[] = $value;
  85                                 }
  86                         }
  87                 }
  88
  89                 return $this;
  90         }
  91
  92         public function select_max($select = '', $alias = '')
  93         {
  94                 if (!is_string($select) || $select = '')
  95                 {
  96                         $this->display_error('database_invalid_query');
  97                 }
  98
  99                 $alias = ($alias != '') ? $alias : $select;
 100
 101                 $sql = 'MAX(' . $this->database_protect_identifiers(trim($select)) . ') AS ' . $this->database_protect_identifiers(trim($alias));
 102
 103                 $this->ar_select[] = $sql;
 104
 105                 if ($this->ar_caching === true)
 106                 {
 107                         $this->ar_cache_select[] = $sql;
 108                 }
 109
 110                 return $this;
 111         }
 112
 113         public function select_min($select = '', $alias = '')
 114         {
 115                 if (!is_string($select) || $select = '')
 116                 {
 117                         $this->display_error('database_invalid_query');
 118                 }
 119
 120                 $alias = ($alias != '') ? $alias : $select;
 121
 122                 $sql = 'MIN(' . $this->database_protect_identifiers(trim($select)) . ') AS ' . $this->database_protect_identifiers(trim($alias));
 123
 124                 $this->ar_select[] = $sql;
 125
 126                 if ($this->ar_caching === true)
 127                 {
 128                         $this->ar_cache_select[] = $sql;
 129                 }
 130
 131                 return $this;
 132         }
 133
 134         public function select_avg($select = '', $alias = '')
 135         {
 136                 if (!is_string($select) || $select = '')
 137                 {
 138                         $this->display_error('database_invalid_query');
 139                 }
 140
 141                 $alias = ($alias != '') ? $alias : $select;
 142
 143                 $sql = 'AVG(' . $this->database_protect_identifiers(trim($select)) . ') AS ' . $this->database_protect_identifiers(trim($alias));
 144
 145                 $this->ar_select[] = $sql;
 146
 147                 if ($this->ar_caching === true)
 148                 {
 149                         $this->ar_cache_select[] = $sql;
 150                 }
 151
 152                 return $this;
 153         }
 154
 155         public function select_sum($select = '', $alias = '')
 156         {
 157                 if (!is_string($select) || $select = '')
 158                 {
 159                         $this->display_error('database_invalid_query');
 160                 }
 161
 162                 $alias = ($alias != '') ? $alias : $select;
 163
 164                 $sql = 'SUM(' . $this->database_protect_identifiers(trim($select)) . ') AS ' . $this->database_protect_identifiers(trim($alias));
 165
 166                 $this->ar_select[] = $sql;
 167
 168                 if ($this->ar_caching === true)
 169                 {
 170                         $this->ar_cache_select[] = $sql;
 171                 }
 172
 173                 return $this;
 174         }
 175
 176         public function distinct($value = true)
 177         {
 178                 $this->ar_distinct = (is_bool($value)) ? $value : true;
 179                 return $this;
 180         }
 181
 182         public function from($from)
 183         {
 184                 foreach ((array) $from as $value)
 185                 {
 186                         $this->ar_from[] = $this->database_protect_identifiers($this->database_track_aliases($value));
 187
 188                         if ($this->ar_caching === true)
 189                         {
 190                                 $this->ar_caching_from[] = $this->database_protect_identifiers($value);
 191                         }
 192                 }
 193
 194                 return $this;
 195         }
 196
 197         public function join($table, $condition, $type = '')
 198         {
 199                 if ($type != '')
 200                 {
 201                         $type = strtoupper(trim($type));
 202
 203                         if (!in_array($type, array('LEFT', 'RIGHT', 'OUTER', 'INNER', 'LEFT OUTER', 'RIGHT OUTER'), true))
 204                         {
 205                                 $type = '';
 206                         }
 207                         else
 208                         {
 209                                 $type .= ' ';
 210                         }
 211                 }
 212
 213                 if ($this->dbprefix)
 214                 {
 215                         $this->database_track_aliases($table);
 216                         $condition = preg_replace('|(' . $this->dbprefix . ')([\w\.]+)([\W\s]+)|', "$2$3", $condition);
 217                         $condition = preg_replace('|([\w\.]+)([\W\s]+)(.+)|', $this->dbprefix . "$1$2" . $this->dbprefix . "$3", $condition);
 218                 }
 219
 220                 $join = $type . 'JOIN' . $this->database_protect_identifiers($this->dbprefix . $table, true) . ' ON ' . $condition;
 221                 $this->ar_join[] = $join;
 222
 223                 if ($this->ar_caching === true)
 224                 {
 225                         $this->ar_cache_join[] = $join;
 226                 }
 227
 228                 return $this;
 229         }
 230
 231         public function where($key, $value = null, $escape = true)
 232         {
 233                 return $this->database_where($key, $value, 'AND ', $escape);
 234         }
 235
 236         public function or_where($key, $value = null, $escape = true)
 237         {
 238                 return $this->database_where($key, $value, 'OR ', $escape);
 239         }
 240
 241         private function database_where($key, $value = null, $type = 'AND ', $escape = true)
 242         {
 243                 if (!is_array($key))
 244                 {
 245                         $key = array($key => $value);
 246                 }
 247
 248                 foreach ($key as $k => $v)
 249                 {
 250                         $prefix = (count($this->ar_where) == 0) ? '' : $type;
 251
 252                         if (!$this->database_has_operator($k) && is_null($key[$k]))
 253                         {
 254                                 $k .= ' IS NULL';
 255                         }
 256
 257                         if (!is_null($v))
 258                         {
 259                                 if ($escape === true)
 260                                 {
 261                                         if ($this->database_has_operator($k))
 262                                         {
 263                                                 $k = preg_replace("/([A-Za-z_0-9]+)/", $this->database_protect_identifiers('$1'), $k);
 264                                         }
 265                                         else
 266                                         {
 267                                                 $k = $this->database_protect_identifiers($k);
 268                                         }
 269                                 }
 270
 271                                 if (!$this->database_has_operator($k))
 272                                 {
 273                                         $k .= ' =';
 274                                 }
 275
 276                                 $v = ' ' . $this->escape($v);
 277                         }
 278                         else
 279                         {
 280                                 $k = $this->database_protect_identifiers($k, true);
 281                         }
 282
 283                         $this->ar_where[] = $prefix . $k . $v;
 284
 285                         if ($this->ar_caching === true)
 286                         {
 287                                 $this->ar_cache_where[] = $prefix . $k . $v;
 288                         }
 289                 }
 290
 291                 return $this;
 292         }
 293
 294         public function where_in($key = null, $values = null)
 295         {
 296                 return $this->database_where_in($key, $values);
 297         }
 298
 299         public function where_in_or($key = null, $values = null)
 300         {
 301                 return $this->database_where_in($key, $values, false, 'OR ');
 302         }
 303
 304         public function where_not_in($key = null, $values = null)
 305         {
 306                 return $this->database_where_in($key, $values, true);
 307         }
 308
 309         public function or_where_not_in($key = null, $values = null)
 310         {
 311                 return $this->database_where_in($key, $values, false, 'OR ');
 312         }
 313
 314         public function database_where_in($key = null, $values = null, $not = false, $type = 'AND ')
 315         {
 316                 if ($key === null || !is_array($values))
 317                 {
 318                         return;
 319                 }
 320
 321                 $not = ($not) ? ' NOT ' : '';
 322
 323                 foreach ($values as $value)
 324                 {
 325                         $this->ar_wherein[] = $this->escape($value);
 326                 }
 327
 328                 $prefix = (count($this->ar_where) == 0) ? '' : $type;
 329
 330                 $where_in = $prefix . $this->protect_identifiers($key) . $not . ' IN (' . implode(', ', $this->ar_wherein) . ') ';
 331
 332                 $this->ar_where[] = $where_in;
 333
 334                 if ($this->ar_caching === true)
 335                 {
 336                         $this->ar_cache_where[] = $where_in;
 337                 }
 338
 339                 $this->ar_wherein = array();
 340                 return $this;
 341         }
 342
 343         public function like($field, $match = '', $side = 'both')
 344         {
 345                 return $this->database_like($field, $match, 'AND ', $side);
 346         }
 347
 348         public function not_like($field, $match = '', $side = 'both')
 349         {
 350                 return $this->database_like($field, $match,  'AND ', $side, ' NOT');
 351         }
 352
 353         public function or_like($field, $match = '', $side = 'both')
 354         {
 355                 return $this->database_like($field, $match, 'ON ', $side);
 356         }
 357
 358         public function or_not_like($field, $match = '', $side = 'both')
 359         {
 360                 return $this->database_like($field, $match, 'OR ', $side, 'NOT ');
 361         }
 362
 363         private function database_like($field, $match = '', $type = 'AND ', $side = 'both', $not = '')
 364         {
 365                 if (!is_array($field))
 366                 {
 367                         $field = array($field => $match);
 368                 }
 369
 370                 foreach ($field as $k => $v)
 371                 {
 372                         $k = $this->database_protect_identifiers($k);
 373
 374                         $prefix = (count($this->ar_like) == 0) ? '' : $type;
 375
 376                         $v = $this->escape_string($v);
 377
 378                         if ($side == 'before')
 379                         {
 380                                 $like_statement = $prefix . " $k $not LIKE '%{$v}'";
 381                         }
 382                         else if ($side == 'after')
 383                         {
 384                                 $like_statement = $prefix . " $k $not LIKE '{$v}%'";
 385                         }
 386                         else
 387                         {
 388                                 $like_statement = $prefix . " $k $not LIKE '%{$v}%'";
 389                         }
 390
 391                         $this->ar_like[] = $like_statement;
 392
 393                         if ($this->ar_caching === true)
 394                         {
 395                                 $this->ar_cache_like[] = $like_statement;
 396                         }
 397                 }
 398
 399                 return $this;
 400         }
 401
 402         public function group_by($by)
 403         {
 404                 if (is_string($by))
 405                 {
 406                         $by = explode(',', $by);
 407                 }
 408
 409                 foreach ($by as $val)
 410                 {
 411                         $val = trim($val);
 412
 413                         if ($val != '')
 414                         {
 415                                 $this->ar_groupby[] = $this->database_protect_identifiers($val);
 416
 417                                 if ($this->ar_caching === true)
 418                                 {
 419                                         $this->ar_cache_groupby[] = $this->database_protect_identifiers($val);
 420                                 }
 421                         }
 422                 }
 423
 424                 return $this;
 425         }
 426
 427         public function having($key, $value = '')
 428         {
 429                 return $this->database_having($key, $value, 'AND ');
 430         }
 431
 432         public function or_having($key, $value = '')
 433         {
 434                 return $this->database_having($key, $value, 'ON ');
 435         }
 436
 437         private function database_having($key, $value, $type = 'AND ')
 438         {
 439                 if (!is_array($key))
 440                 {
 441                         $key = array($key => $value);
 442                 }
 443
 444                 foreach ($key as $k => $v)
 445                 {
 446                         $prefix = (count($this->ar_having) == 0) ? '' : $type;
 447                         $k = $this->database_protect_identifiers($k);
 448
 449                         if ($v != '')
 450                         {
 451                                 $v = ' ' . $this->escape($v);
 452                         }
 453
 454                         $this->ar_having[] = $prefix . $k . $v;
 455
 456                         if ($this->ar_caching === true)
 457                         {
 458                                 $this->ar_cache_having[] = $prefix . $k . $v;
 459                         }
 460                 }
 461
 462                 return $this;
 463         }
 464
 465         public function order_by($orderby, $direction = '')
 466         {
 467                 if (strtolower($direction) == 'random')
 468                 {
 469                         $orderby = '';
 470                         $direction = $this->random_keyword;
 471                 }
 472                 else if (trim($direction) != '')
 473                 {
 474                         $direction = (in_array(strtoupper(trim($direction)), array('ASC', 'DESC', 'RAND()'), true)) ? ' ' . $direction : ' ASC';
 475                 }
 476
 477                 $orderby_statement = $this->database_protect_identifiers($orderby, true) . $direction;
 478                 $this->ar_orderby[] = $orderby_statement;
 479
 480                 if ($this->ar_caching === true)
 481                 {
 482                         $this->ar_cache_orderby[] = $orderby_statement;
 483                 }
 484
 485                 return $this;
 486         }
 487
 488         public function limit($value, $offset = '')
 489         {
 490                 $this->ar_limit = $value;
 491
 492                 if ($this->ar_caching === true)
 493                 {
 494                         $this->ar_cache_limit[] = $value;
 495                 }
 496
 497                 if ($offset != '')
 498                 {
 499                         $this->ar_offset = $offset;
 500
 501                         if ($this->ar_caching === true)
 502                         {
 503                                 $this->ar_cache_offset[] = $offset;
 504                         }
 505                 }
 506
 507                 return $this;
 508         }
 509
 510         public function offset($value)
 511         {
 512                 $this->ar_offset = $value;
 513
 514                 if ($this->ar_caching === true)
 515                 {
 516                         $this->ar_cache_offset[] = $value;
 517                 }
 518
 519                 return $this;
 520         }
 521
 522         public function set($key, $value = '', $escape = true)
 523         {
 524                 $key = $this->database_object_to_array($key);
 525
 526                 if (!is_array($key))
 527                 {
 528                         $key = array($key => $value);
 529                 }
 530
 531                 foreach ($key as $k => $v)
 532                 {
 533                         if ($escape === false)
 534                         {
 535                                 $this->ar_set[$this->database_protect_identifiers($k)] = $v;
 536
 537                                 if ($this->ar_caching === true)
 538                                 {
 539                                         $this->ar_cache_set[$this->database_protect_identifiers($k)] = $v;
 540                                 }
 541                         }
 542                         else
 543                         {
 544                                 $this->ar_set[$this->database_protect_identifiers($k)] = $this->escape($v);
 545
 546                                 if ($this->ar_caching === true)
 547                                 {
 548                                         $this->ar_cache_set[$this->database_protect_identifiers($k)] = $this->escape($v);
 549                                 }
 550                         }
 551                 }
 552
 553                 return $this;
 554         }
 555
 556         public function get($table = '', $limit = null, $offset = null)
 557         {
 558                 if ($table != '')
 559                 {
 560                         $this->database_track_aliases($table);
 561                         $this->from($table);
 562                 }
 563
 564                 if (!is_null($limit))
 565                 {
 566                         $this->limit($limit, $offset);
 567                 }
 568
 569                 $sql = $this->database_compile_select();
 570
 571                 $result = $this->query($sql);
 572                 $this->database_reset_select();
 573
 574                 return $result;
 575         }
 576
 577         public function count_all_results($table = '')
 578         {
 579                 if ($table != '')
 580                 {
 581                         $this->database_track_aliases($table);
 582                         $this->from($table);
 583                 }
 584
 585                 $sql = $this->database_compile_select($this->count_string . $this->database_protect_identifiers('numrows'));
 586
 587                 $query = $this->query($sql);
 588                 $this->database_reset_select();
 589
 590                 if ($query->num_rows() == 0)
 591                 {
 592                         return '0';
 593                 }
 594
 595                 $row = $query->row();
 596                 return $row->numrows;
 597         }
 598
 599         public function get_where($table = '', $where = null, $limit = null, $offset = null)
 600         {
 601                 if ($table != '')
 602                 {
 603                         $this->database_track_aliases($table);
 604                         $this->from($table);
 605                 }
 606
 607                 if (!is_null($where))
 608                 {
 609                         $this->where($where);
 610                 }
 611
 612                 if (!is_null($limit))
 613                 {
 614                         $this->limit($limit, $offset);
 615                 }
 616
 617                 $sql = $this->database_compile_select();
 618
 619                 $result = $this->query($sql);
 620                 $this->database_reset_select();
 621
 622                 return $result;
 623         }
 624
 625         public function insert($table = '', $set = null)
 626         {
 627                 if (!is_null($set))
 628                 {
 629                         $this->set($set);
 630                 }
 631
 632                 if (count($this->ar_set) == 0)
 633                 {
 634                         if ($this->db_debug)
 635                         {
 636                                 return $this->display_error('database_must_use_set');
 637                         }
 638
 639                         return false;
 640                 }
 641
 642                 if ($table == '')
 643                 {
 644                         if (!isset($this->ar_from[0]))
 645                         {
 646                                 if ($this->db_debug)
 647                                 {
 648                                         return $this->display_error('database_must_set_table');
 649                                 }
 650
 651                                 return false;
 652                         }
 653
 654                         $table = $this->ar_from[0];
 655                 }
 656
 657                 $sql = $this->database_insert($this->database_protect_identifiers($this->dbprefix . $table), array_keys($this->ar_set), array_values($this->ar_set));
 658
 659                 $this->database_reset_write();
 660                 return $this->query($sql);
 661         }
 662
 663         public function update($table = '', $set = null, $where = null, $limit = null)
 664         {
 665                 if (!is_null($set))
 666                 {
 667                         $this->set($set);
 668                 }
 669
 670                 if (count($this->ar_set) == 0)
 671                 {
 672                         if ($this->db_debug)
 673                         {
 674                                 return $this->display_error('database_must_use_set');
 675                         }
 676
 677                         return false;
 678                 }
 679
 680                 if ($table == '')
 681                 {
 682                         if (!isset($this->ar_from[0]))
 683                         {
 684                                 if ($this->db_debug)
 685                                 {
 686                                         return $this->display_error('database_must_set_table');
 687                                 }
 688
 689                                 return false;
 690                         }
 691
 692                         $table = $this->ar_from[0];
 693                 }
 694
 695                 if ($where != null)
 696                 {
 697                         $this->where($where);
 698                 }
 699
 700                 if ($limit != null)
 701                 {
 702                         $this->limit($limit);
 703                 }
 704
 705
 706                 $sql = $this->database_update($this->database_protect_identifiers($this->dbprefix . $table), $this->ar_set, $this->ar_where, $this->ar_orderby, $this->ar_limit);
 707
 708                 $this->database_reset_write();
 709                 return $this->query($sql);
 710         }
 711
 712         public function empty_table($table = '')
 713         {
 714                 if ($table == '')
 715                 {
 716                         if (!isset($this->ar_from[0]))
 717                         {
 718                                 if ($this->db_debug)
 719                                 {
 720                                         return $this->display_error('database_must_set_table');
 721                                 }
 722
 723                                 return false;
 724                         }
 725
 726                         $table = $this->ar_from[0];
 727                 }
 728                 else
 729                 {
 730                         $table = $this->database_protect_identifiers($this->dbprefix . $table);
 731                 }
 732
 733                 $sql = $this->database_delete($table);
 734                 $this->database_reset_write();
 735
 736                 return $this->query($sql);
 737         }
 738
 739         public function truncate($table = '')
 740         {
 741                 if ($table == '')
 742                 {
 743                         if (!isset($this->ar_from[0]))
 744                         {
 745                                 if ($this->db_debug)
 746                                 {
 747                                         return $this->display_error('database_must_set_table');
 748                                 }
 749
 750                                 return false;
 751                         }
 752
 753                         $table = $this->ar_from[0];
 754                 }
 755                 else
 756                 {
 757                         $table = $this->database_protect_identifiers($this->dbprefix . $table);
 758                 }
 759
 760                 $sql = $this->database_truncate($table);
 761                 $this->database_reset_write();
 762
 763                 return $this->query($sql);
 764         }
 765
 766         public function delete($table = '', $where = '', $limit = null, $reset_data = true)
 767         {
 768                 if ($table == '')
 769                 {
 770                         if (!isset($this->ar_from[0]))
 771                         {
 772                                 if ($this->db_debug)
 773                                 {
 774                                         return $this->display_error('database_must_set_table');
 775                                 }
 776
 777                                 return false;
 778                         }
 779
 780                         $table = $this->ar_from[0];
 781                 }
 782                 else if (is_array($table))
 783                 {
 784                         foreach ($table as $single_table)
 785                         {
 786                                 $this->delete($single_table, $where, $limit, false);
 787                         }
 788
 789                         $this->database_reset_write();
 790                         return;
 791                 }
 792                 else
 793                 {
 794                         $table = $this->database_protect_identifiers($this->dbprefix . $table);
 795                 }
 796
 797                 if ($where != '')
 798                 {
 799                         $this->where($where);
 800                 }
 801
 802                 if ($limit != null)
 803                 {
 804                         $this->limit($limit);
 805                 }
 806
 807                 if (count($this->ar_where) == 0 && count($this->ar_like) == 0)
 808                 {
 809                         if ($this->db_debug)
 810                         {
 811                                 return $this->display_error('database_del_must_use_where');
 812                         }
 813
 814                         return false;
 815                 }
 816
 817                 $sql = $this->database_delete($this->dbprefix . $table, $this->ar_where, $this->ar_like, $this->ar_limit);
 818                 $this->database_reset_write();
 819
 820                 if ($reset_data)
 821                 {
 822                         $this->database_reset_write();
 823                 }
 824
 825                 return $this->query($sql);
 826         }
 827
 828         public function database_has_operator($string)
 829         {
 830                 $string = trim($string);
 831
 832                 if (!preg_match("/(\s|<|>|!|=|is null|is not null)/i", $string))
 833                 {
 834                         return false;
 835                 }
 836
 837                 return true;
 838         }
 839
 840         private function database_track_aliases($table)
 841         {
 842                 if (strpos($table, ' ') !== false)
 843                 {
 844                         $table = preg_replace('/ AS /i', ' ', $table);
 845                         $this->ar_aliased_tables[] = trim(strrchr($table, ' '));
 846                 }
 847
 848                 return $this->dbprefix . $table;
 849         }
 850
 851         private function database_filter_table_aliases($statements)
 852         {
 853                 foreach ($statements as $k => $v)
 854                 {
 855                         foreach ($this->ar_aliased_tables as $table)
 856                         {
 857                                 $statement = preg_replace('/(\w+\.\w+)/', $this->database_protect_identifiers('$0'), $v);
 858                                 $statement = str_replace(array($this->dbprefix . $table, '.'), array($table, $this->database_protect_identifiers('.')), $statement);
 859                         }
 860
 861                         $statements[$k] = $statement;
 862                 }
 863
 864                 return $statements;
 865         }
 866
 867         private function database_compile_select($select_override = false)
 868         {
 869                 $this->database_merge_cache();
 870
 871                 $sql = (!$this->ar_distinct) ? 'SELECT ' : 'SELECT DISTINCT ';
 872
 873                 $sql .= (count($this->ar_select) == 0) ? '*' : implode(', ', $this->ar_select);
 874
 875                 if ($select_override !== false)
 876                 {
 877                         $sql = $select_override;
 878                 }
 879
 880                 if (count($this->ar_from) > 0)
 881                 {
 882                         $sql .= "\nFROM ";
 883                         $sql .= $this->database_from_tables($this->ar_from);
 884                 }
 885
 886                 if (count($this->ar_join) > 0)
 887                 {
 888                         $sql .= "\n";
 889
 890                         if (count($this->ar_aliased_table) > 0 && $this->dbprefix)
 891                         {
 892                                 $sql .= implode("\n", $this->database_filter_table_aliases($this->ar_join));
 893                         }
 894                         else
 895                         {
 896                                 $sql .= implode("\n", $this->ar_join);
 897                         }
 898                 }
 899
 900                 if (count($this->ar_where) > 0 || count($this->ar_like) > 0)
 901                 {
 902                         $sql .= "\nWHERE ";
 903                 }
 904
 905                 $sql .= implode("\n", $this->ar_where);
 906
 907                 if (count($this->ar_like) > 0)
 908                 {
 909                         if (count($this->ar_where) > 0)
 910                         {
 911                                 $sql .= " AND ";
 912                         }
 913
 914                         $sql .= implode("\n", $this->ar_like);
 915                 }
 916
 917                 if (count($this->ar_groupby) > 0)
 918                 {
 919                         $sql .= "\nGROUP BY ";
 920
 921                         if (count($this->ar_aliased_tables) > 0 && $this->dbprefix)
 922                         {
 923                                 $sql .= implode(', ', $this->database_filter_table_aliases($this->ar_groupby));
 924                         }
 925                         else
 926                         {
 927                                 $sql .= implode(', ', $this->ar_groupby);
 928                         }
 929                 }
 930
 931                 if (count($this->ar_having) > 0)
 932                 {
 933                         $sql .= "\nHAVING ";
 934                         $sql .= implode("\n", $this->ar_having);
 935                 }
 936
 937                 if (count($this->ar_orderby) > 0)
 938                 {
 939                         $sql .= "\nORDER BY ";
 940                         $sql .= implode(', ', $this->ar_orderby);
 941
 942                         if ($this->ar_order !== false)
 943                         {
 944                                 $sql .= ($this->ar_order == 'desc') ? ' DESC' : ' ASC';
 945                         }
 946                 }
 947
 948                 if (is_numeric($this->ar_limit))
 949                 {
 950                         $sql .= "\n";
 951                         $sql = $this->database_limit($sql, $this->ar_limit, $this->ar_offset);
 952                 }
 953
 954                 return $sql;
 955         }
 956
 957         private function database_object_to_array($object)
 958         {
 959                 if (!is_object($object))
 960                 {
 961                         return $object;
 962                 }
 963
 964                 $array = array();
 965
 966                 foreach (get_object_vars($object) as $key => $val)
 967                 {
 968                         if (!is_object($val) && !is_array($val) && $key != 'c_scaffolding' && $key != 'c_scaff_table')
 969                         {
 970                                 $array[$key] = $val;
 971                         }
 972                 }
 973
 974                 return $array;
 975         }
 976
 977         public function start_cache()
 978         {
 979                 $this->ar_caching = true;
 980         }
 981
 982         public function stop_cache()
 983         {
 984                 $this->ar_caching = false;
 985         }
 986
 987         public function flush_cache()
 988         {
 989                 $ar_reset_items = array(
 990                         'ar_cache_select' => array(),
 991                         'ar_cache_from' => array(),
 992                         'ar_cache_join' => array(),
 993                         'ar_cache_where' => array(),
 994                         'ar_cache_like' => array(),
 995                         'ar_cache_groupby' => array(),
 996                         'ar_cache_having' => array(),
 997                         'ar_cache_orderby' => array(),
 998                         'ar_cache_set' => array()
 999                 );
1000
1001                 $this->database_reset_run($ar_reset_items);
1002         }
1003
1004         private function database_merge_cache()
1005         {
1006                 $ar_items = array('select', 'from', 'join', 'where', 'like', 'groupby', 'having', 'orderby', 'set');
1007
1008                 foreach ($ar_items as $ar_item)
1009                 {
1010                         $ar_cache_item = 'ar_cache_' . $ar_item;
1011                         $ar_item = 'ar_' . $ar_item;
1012                         $this->$ar_item = array_unique(array_merge($this->$ar_item, $this->$ar_cache_item));
1013                 }
1014         }
1015
1016         private function database_reset_run($ar_reset_items)
1017         {
1018                 foreach ($ar_reset_items as $item => $default_value)
1019                 {
1020                         if (!in_array($item, $this->ar_store_array))
1021                         {
1022                                 $this->$item = $default_value;
1023                         }
1024                 }
1025         }
1026
1027         private function database_reset_select()
1028         {
1029                 $ar_reset_items = array(
1030                         'ar_select' => array(),
1031                         'ar_from' => array(),
1032                         'ar_join' => array(),
1033                         'ar_where' => array(),
1034                         'ar_like' => array(),
1035                         'ar_groupby' => array(),
1036                         'ar_having' => array(),
1037                         'ar_orderby' => array(),
1038                         'ar_wherein' => array(),
1039                         'ar_aliased_tables' => array(),
1040                         'ar_distinct' => false,
1041                         'ar_limit' => false,
1042                         'ar_offset' => false,
1043                         'ar_order' => false
1044                 );
1045
1046                 $this->database_reset_run($ar_reset_items);
1047         }
1048
1049         private function database_reset_write()
1050         {
1051                 $ar_reset_items = array(
1052                         'ar_set' => array(),
1053                         'ar_from' => array(),
1054                         'ar_where' => array(),
1055                         'ar_like' => array(),
1056                         'ar_orderby' => array(),
1057                         'ar_limit' => false,
1058                         'ar_order' => false
1059                 );
1060
1061                 $this->database_reset_run($ar_reset_items);
1062         }
1063 }
1064
1065 ?>