_res/_libs/tdoabstract.class.php

   1 <?php
   2 /**
   3  * @desc The Abstract Data Objects series
   4  *
   5  * @author Marius Orcsik <marius.orcsik@gmail.com>
   6  * @version 0.0.1
   7  */
   8
   9 class tdoAbstract {
  10         /**
  11          * @var mySqlIm $db
  12          */
  13         public  $db,
  14                         $wheres = array(),
  15                         $groups,
  16                 //      $orders,
  17                         $limit,
  18                         $refers = array();
  19
  20         protected       $id,    // public to allow debugging outside the class
  21                                 $name,
  22                                 $alias,
  23                                 $fields;
  24
  25         /**
  26          * @desc function to implement get_ | set_ virtual methods
  27          *
  28          * @param string $method
  29          * @param array $args
  30          * @return bool|mixed
  31          *
  32          * @see  http://www.ibm.com/developerworks/xml/library/os-php-flexobj/ by Jack Herrington <jherr@pobox.com>
  33          */
  34         function __call ( $method, $args) {
  35                 $diff = $this->get_members();
  36                 $all = get_object_vars($this);
  37
  38                 if ( preg_match( '/set_(.*)/', $method, $found ) ) {
  39                         // check for fields with $found[1] name
  40                         if ( array_key_exists( $found[1], $diff) ) {
  41                                 $this->fields[$found[1]]->setValue($args[0]);
  42                                 return true;
  43                                 // check for obj members with $found[1] name
  44                         } elseif  (array_key_exists( $found[1], $all)){
  45                                 $this->$found[1] = $args[0];
  46                                 return true;
  47                         }
  48                 } else if ( preg_match( '/get_(.*)/', $method, $found ) ) {
  49                         if ( array_key_exists( $found[1], $diff ) ) {
  50                                 return $this->fields[$found[1]]->getValue();
  51                         } elseif  (array_key_exists( $found[1], $all)){
  52                                 return $this->$found[1];
  53                         }
  54                 }
  55                 return false;
  56         }
  57
  58         /**
  59          * @desc A function to implement a virtual getter member of the class
  60          *
  61          * @param string $key
  62          * @return mixed
  63          *
  64          * @see  http://www.ibm.com/developerworks/xml/library/os-php-flexobj/ by Jack Herrington <jherr@pobox.com>
  65          */
  66         function __get ( $key ) {
  67                 return $this->fields[$key];
  68         }
  69
  70         /**
  71          * @desc A function to implement a virtual setter member for this class
  72          *
  73          * @param string $key
  74          * @param mixed $value
  75          * @return bool
  76          *
  77          * @see  http://www.ibm.com/developerworks/xml/library/os-php-flexobj/ by Jack Herrington <jherr@pobox.com>
  78          */
  79         function __set ( $key, $value ) {
  80                 if (
  81                 array_key_exists ($key, $this->get_members()) /*&&
  82                 $this->isValidMember($this->fields[$key])*/
  83                 ) {
  84                         $this->fields[$key]->set_value ($value);
  85                         return true;
  86                 } else {
  87                         $this->fields[$key] = new tdoAbstractField ($key, $this->alias);
  88                         $this->fields[$key]->set_value ($value);
  89                 }
  90         }
  91
  92         public function __construct(&$db) {
  93                 $this->db               = &$db;
  94                 $this->alias    = 'm1';
  95
  96                 $this->instantiateMembers();
  97         }
  98
  99         public function __destruct() {}
 100
 101         /**
 102          * gets the members we consider table fields
 103          *
 104          * @return array ('fieldName' => tdoAbstractField)
 105          */
 106         public function &get_members () {
 107                 return $this->fields;
 108         }
 109
 110         /**
 111          * checks if a field is a valid member of the current object
 112          *
 113          * @param tdoAbstractField $incMember
 114          * @return bool
 115          */
 116         public function isValidMember ($incMember) {
 117                 if (
 118                         ! ($incMember instanceof tdoAbstractField ) ||
 119                         // this prevents an error in php > 5.2 object comparison
 120                         ! in_array ($incMember, $this->get_members() /**/, true/**/)
 121                 ) {
 122                         return false;
 123                 } else
 124                         return true;
 125         }
 126
 127         /**
 128          * instantiating the object's members
 129          */
 130         public function instantiateMembers () {
 131                 foreach ($this->get_members() as $key => $field) {
 132                         if ( is_int ($key) && is_string ($field) ) {
 133                                 $this->fields[$field] = new tdoAbstractField ($field, $this->alias);
 134
 135                                 // FIXME: this is so bad :D - it implies that the primary key must be the first field containing _id :D
 136                                 if (stristr ($field,'_id') && !isset ($this->id) && $this->isValidMember ($this->fields[$field])) {
 137                                         $this->id = &$this->fields[$field];
 138                                 }
 139                                 unset ($this->fields[$key]);
 140                         }
 141                 }
 142
 143                 $this->wheres           = array();
 144                 $this->groups           = '';
 145 //              $this->orders           = '';
 146                 $this->refers           = array();
 147         }
 148         /**
 149          * setting the table's index field
 150          *
 151          * @param tdoAbstractField $obj
 152          */
 153         public function set_index (&$obj) {
 154                 if ($this->isValidMember($obj)) {
 155                         $this->id       = &$obj;
 156                         $this->id->flags = PRIMARY;
 157                 }
 158         }
 159
 160         /**
 161          * setting an alias for the table in case of joins.
 162          * this method also sets the alias on all the fields of the current object
 163          *
 164          * @param string $alias
 165          */
 166         public function set_alias ($alias) {
 167                 foreach ($this->get_members() as $field){
 168                         if ($field->table == $this->alias) {
 169                                 $field->table = 't'.$alias;
 170                         }
 171                 }
 172                 $this->alias = 't'.$alias;
 173         }
 174
 175         /**
 176          * For adding custom sql functions for certain fields
 177          *
 178          * @param string $modif
 179          * @param tdoAbstractField $field
 180          */
 181         public function set_fieldModifier ($modif, &$field) {
 182                 if ($this->isValidMember ($field) && stristr ($modif, '%'))
 183                 $field->set_modifier ($modif);
 184         }
 185
 186         /**
 187          * method used in join cases to add the joined object's fields
 188          * to the current one
 189          *
 190          * @param array ('fieldName' => tdoAbstractField) $incArr
 191          */
 192         public function addFields (&$incArr) {
 193                 if (is_array($incArr)) {
 194                         foreach ($incArr as $fieldName => $field) {
 195                                 $this->fields[$fieldName]       = $field;
 196                         }
 197                 }
 198         }
 199
 200         /**
 201          * Based on field values, we get the _first_ row in the table that matches
 202          *
 203          * TODO: maybe we can have a function that returns _all_ the rows that match
 204          *
 205          * @return bool
 206          */
 207         public function buildObj () {
 208                 $sql = $this->buildSql(1);
 209                 $this->db->query( $sql );
 210
 211                 $arr = $this->db->getAssoc();
 212                 if (is_array($arr)) {
 213                         foreach ($arr as $field => $var) {
 214                                 $this->fields[$field]->set_value ($var);
 215                         }
 216                         return true;
 217                 }
 218                 return false;
 219         }
 220
 221         /**
 222          * Gets the row in the table for $id
 223          *
 224          * @param mixed $id
 225          */
 226
 227         public function get ($id) {
 228                 $id = $this->db->escape($id);
 229
 230                 $this->instantiateMembers();
 231
 232                 $this->id->set_value ($id);
 233                 $this->buildObj ();
 234         }
 235         /**
 236          * Returns the last id of the table
 237          * OBS: this assumes that we didn't delete any rows from the table.
 238          *
 239          * @return int
 240          */
 241         public function getLastInsertedId () {
 242                 $sql = $this->db->_SELECT ($this->id->name)
 243                         .$this->db->_FROM ($this->name) . $this->db->_AS ($this->alias);
 244
 245                 $this->addOrder ($this->id, false);
 246
 247                 $sql .= $this->db->_ORDER ($this->outputOrders ());
 248
 249                 $sql .= $this->db->_LIMIT (1);
 250
 251                 $this->db->query ($sql);
 252                 return $this->db->getScalar ();
 253         }
 254
 255         /**
 256          * encapsulating the $this->db->escape() method
 257          *
 258          * @param mixed $value
 259          * @return mixed
 260          */
 261         public function escape ($value) {
 262                 if (is_numeric ($value)) {
 263                         return (int)$value;
 264                 } else {
 265                         // this behavior is broken for PostgreSQL as it encloses values in apostrophes
 266                         return '"' . $this->db->escape ($value) . '"';
 267                 }
 268         }
 269         /**
 270          * inserting into the database
 271          * TODO: multiple inserts to use with loadFromArray
 272          *
 273          * @return int
 274          */
 275         public function insert () {
 276                 $sql = $this->db->_INSERT ($this->name);//`'INSERT INTO '.$this->name;
 277
 278                 $fieldStr = '';
 279                 $valueStr = '';
 280                 $values = array ();
 281                 $f = $this->get_members();
 282
 283 //              $sql .= ' '.$this->outputRefers().' SET';
 284
 285                 foreach ($f as $fieldName => $field) {
 286                         if ($this->isValidMember ($field) && ($field != $this->id) && !is_null ($field->value)) {
 287                                 $value = $this->escape ($field->value);
 288                                 $value = $field->value;
 289
 290                                 $fieldStr.= (!empty ($fieldStr) ? ', ' : ' ') . $fieldName;
 291                                 $valueStr.= (!empty ($valueStr) ? ', ' : ' ') . $value;
 292                                 $values[] = $value;
 293                         }
 294                 }
 295
 296                 $sql.= ' ('.$fieldStr.') VALUES ('.$valueStr.')';
 297 //              $sql.= ' ('.$fieldStr.')' . $this->db->_VALUES ($values); // VALUES ('.$valueStr.')';
 298                 if ($fieldStr) {
 299                         $this->db->query($sql);
 300
 301                         return $this->getLastInsertedId();
 302                 }
 303         }
 304
 305         public function update ($id = null) {
 306                 if (is_null ($id)) {
 307                         $id = $this->id->value;
 308                 }
 309
 310                 if (is_null ($id)) {
 311                         throw new Exception('Cannot update record in table '.$this->name.' because an id hasn\'t been provided');
 312                         return false;
 313                 }
 314
 315                 $sql = $this->db->_UPDATE (array ($this->name, $this->alias) );
 316
 317                 if (is_array ($this->refers) && !empty ($this->refers)){
 318                         $this->refers = array_reverse ($this->refers);
 319
 320                         foreach ($this->refers as $ref)
 321                         $sql .= $ref;
 322                 }
 323
 324                 $sql .= $this->db->_SET();
 325
 326                 $fields = $this->get_members();
 327
 328                 foreach ($fields as $fieldName => $field) {
 329                         if (($field instanceof tdoAbstractField) && $field != $this->id) { // TODO: make a more real check for field is an id
 330                         $value = $field->value;
 331                         }
 332
 333                         if ((isset($value) && !is_null($value))) {
 334                                 $sql.= $field->table.'.'.$fieldName.' = '.$this->escape ($value).', ';
 335                         }
 336                 }
 337
 338                 $sql = substr ($sql, 0, -2);
 339
 340                 $sql.= $this->db->_WHERE($this->alias.'.'.$this->id->name.' = '.$this->escape($id));
 341
 342 //              var_dump($sql);die ('<br/>update');
 343                 $this->db->query($sql);
 344
 345                 return $id;
 346         }
 347
 348         public function replace ( $id = null ) {
 349                 if (is_null($id)) {
 350                         $id = $this->id->value;
 351                 }
 352
 353                 if (is_null($id) || !$this->idExists ($id) ) {
 354                         return $this->insert ();
 355                 } else {
 356                         return $this->update ($id);
 357                 }
 358         }
 359
 360         // TODO: make this the same way the find first method works
 361         public function delete ($id = null) {
 362                 $id = (!is_null ($id) ? $id :$this->id->value);
 363
 364                 if (!is_null ($id)) {
 365                         // no need for other wheres
 366                         $this->wheres = array();
 367                         $this->addWhere ($this->id, '=', $id);
 368                 }
 369
 370                 if (empty($this->wheres)) {
 371                         return false;
 372                 }
 373
 374                 $temp = $this->alias;
 375                 $this->set_alias(null);
 376
 377
 378                 $sql = 'DELETE FROM '.$this->name.' WHERE '; //$this->id->name.' = '.$this->escape($value).' LIMIT 1';
 379                 $sql.= $this->outputWheres();
 380 //              echo $sql;die;
 381                 $affRows = $this->db->query($sql);
 382
 383                 $this->set_alias($temp);
 384                 return $affRows;
 385         }
 386
 387         public function reset () {
 388                 foreach ($this->fields as $key => $field) {
 389                         if ($field instanceof tdoAbstractField) {
 390                                 $this->fields[$key] = new tdoAbstractField($key, $this->alias);
 391                         }
 392                 }
 393
 394                 $this->wheres           = array();
 395                 $this->groups           = array();
 396 //              $this->orders           = array();
 397                 $this->refers           = array();
 398                 return true;
 399         }
 400
 401         public function idExists ($id = null) {
 402                 if (is_null($id)) {
 403                         $id = $this->id->value;
 404                 }
 405                 if (is_null($id))
 406                         return false;
 407
 408                 $this->id->set_modifier ('COUNT(%s)');
 409
 410                 $t = sprintf ($this->id->modifier,  $this->id->name);
 411
 412                 $sql    = $this->db->_SELECT ($t).
 413                                 $this->db->_FROM ($this->name).
 414                                 $this->db->_WHERE ($this->id->name.' = '.$this->escape($id));
 415
 416                 $this->db->query($sql);
 417
 418                 if ($this->db->getScalar()) {
 419                         return true;
 420                 } else {
 421                         return false;
 422                 }
 423         }
 424
 425         protected function outputFieldList () {
 426                 $fields = '';
 427                 $f      = $this->get_members();
 428                 //              var_dump($f);
 429                 foreach ($f as $fieldName => $field) {
 430                         if ($this->isValidMember ($field)) {
 431
 432                                 if (!is_null ($field->modifier)) {
 433                                         // i replaced str_replace ('%s', $curField, '%s', $curField)
 434                                         // as sometimes I might need it for something else than %s
 435                                         $fields .= sprintf ($field->modifier, (!is_null ($field->table) ? $field->table . '.' : '') . $field->name) .
 436                                         $this->db->_AS($field->name) . ', ';
 437                                 } elseif ( !$field->inWhere ()) {
 438                                         $fields .= (!is_null ($field->table) ? $field->table.'.' : '') . $field->name . ', ';
 439                                 }
 440
 441                         } else {
 442                                 trigger_error ($fieldName . ' is not a valid member of ' . get_class($this));
 443 //                              throw new Exception ($fieldName . ' is not a valid member of ' . get_class($this));
 444                                 return false;
 445                         }
 446                 }
 447                 return substr ($fields,0,-2);//$fields;
 448         }
 449
 450         protected function outputWheres ($bIW = true) {
 451 //              var_dump($this->wheres);
 452                 return implode ($this->db->_AND(), $this->wheres);
 453         }
 454
 455         protected function outputGroups () {
 456                 // groups
 457                 $groups = '';
 458                 $f = $this->get_members ();
 459                 foreach ($f as $field) {
 460                         if (!is_null ($field->group) ) {
 461                                 $groups .= (!empty($groups) ? ', ' : '') .
 462                                                 $field->table . '.' . $field->name;
 463                         }
 464                 }
 465
 466                 return $groups;
 467         }
 468
 469         protected function outputOrders () {
 470                 $orders = '';
 471                 $f = $this->get_members();
 472                 foreach ($f as $field)
 473                 if (!is_null($field->order)) {
 474                         $orders .= (!empty($orders) ? ', ': '') .
 475                                         $field->table . '.' . $field->name .
 476                                         ($field->order == true ? ' ASC' : ' DESC');
 477                 }
 478                 return $orders;
 479         }
 480
 481         protected function outputRefers () {
 482                 $refers= '';
 483                 if (!empty($this->refers) && is_array($this->refers)){
 484                         $rs = array_reverse ($this->refers);
 485                         foreach ($rs as $ref) // using the __toString magic function
 486                                 $refers .= $ref;
 487                 }
 488                 return $refers;
 489         }
 490
 491         protected function buildInherentWheres () {
 492                 $diff   = $this->get_members();
 493                 // let's hope this doesn't break stuff.
 494                 // it's needed when we use more queries on the same instance of the object :D
 495
 496                 if (is_array ($diff)) {
 497                         foreach ($diff as $fieldName => $field) {
 498                                 if ( $this->isValidMember ($field) ) {
 499                                         if (!is_null($field->value))
 500                                                 $this->addWhere ($field, '=', $this->escape($field->value));
 501                                 } else {
 502                                         trigger_error ($fieldName . ' is not a valid member of ' . get_class($this));
 503 //                                      throw new Exception ($fieldName . ' is not a valid member of ' . get_class($this));
 504                                 }
 505                         }
 506                 }
 507
 508                 if (empty ($this->wheres)) {
 509                         $t = '1';
 510                         $this->wheres[] = new tdoAbstractClause ($t);
 511                 }
 512         }
 513
 514         /**
 515          * function to add an abstract clause to the current object if it doesn't exist
 516          *
 517          * @param tdoAbstractField|tdoAbstractClause $field1
 518          * @param string $condition
 519          * @param string $field2
 520          */
 521         public function addWhere (&$field1, $condition = null, $field2 = null) {
 522                 if (($field1 instanceof tdoAbstractClause) && ($condition == null || $field2 == null)) {
 523                         $w = &$field1;
 524                 } else {
 525                         $w = new tdoAbstractClause ($field1, $condition, $field2);
 526                 }
 527                 // this might generate an infinite recursion error on some PHP > 5.2 due to object comparison
 528                 if (!in_array ($w, $this->wheres /*, true */))
 529                 $this->wheres[] = &$w;
 530         }
 531
 532         public function addOrder (&$orderField, $asc = true) {
 533                 if (!($orderField instanceof tdoAbstractField) && is_string ($orderField)) {
 534                         $orderField = &$this->fields[$orderField];
 535                 }
 536                 if ($this->isValidMember ($orderField))
 537                         $orderField->set_order ($asc);
 538         }
 539
 540         public function addGroup (&$groupField) {
 541                 if (!($groupField instanceof tdoAbstractField) && is_string ($groupField)) {
 542                         $groupField = &$this->fields[$groupField];
 543                 }
 544                 if (($groupField instanceof tdoAbstractField)) {
 545                         $groupField->set_group (true);
 546                 }
 547         }
 548
 549         /**
 550          * @param int $start
 551          * @param int $count
 552          */
 553
 554         public function addLimit ($start = 0, $count=null) {
 555                 if (empty($this->limit))
 556                         $this->limit = $this->db->_LIMIT ($start, $count);
 557         }
 558
 559         /**
 560          * building a normal SELECT query
 561          *
 562          * @param int $start
 563          * @param int $end
 564          * @return string
 565          */
 566         protected function buildSql ($start = 0, $count = 0) {
 567                 $sql = $this->db->_SELECT($this->outputFieldList()). ' FROM '.$this->name.' AS '.$this->alias.' ';
 568
 569                 $this->buildInherentWheres(); // will it work
 570
 571                 $sql .= $this->outputRefers();
 572
 573                 $sql .= $this->db->_WHERE ($this->outputWheres());
 574
 575                 $sql .= $this->db->_GROUP ($this->outputGroups());
 576
 577                 $sql .= $this->db->_ORDER ($this->outputOrders());
 578
 579                 if (empty ($this->limit)) {
 580                         $this->addLimit ($start, $count);
 581                 }
 582                 $sql .= $this->limit;
 583                 return $sql;
 584         }
 585
 586         public function find ($start = 0, $count = 0) {
 587                 $result = $this->db->query ($this->buildSql(), $start, $count);
 588                 return $result;
 589         }
 590
 591         public function findFirst () {
 592                 $this->buildInherentWheres();
 593
 594                 $this->db->query($this->buildSql(), 0, 1);
 595                 $row = $this->db->getAssoc();
 596                 if (is_array($row))
 597                         foreach ($row as $field => $value){
 598                                 $this->fields[$field]->value = $value;
 599                         }
 600         }
 601
 602         public function getArray ($start = 0, $count = 0, $orderBy = null) {
 603                 $this->buildInherentWheres ();
 604
 605                 $sql = $this->buildSql ($start, $count, $orderBy);
 606
 607                 $this->db->query ($sql);
 608                 return $this->db->getArray ();
 609         }
 610
 611         /**
 612          * execute a select count () on the current object
 613          *
 614          * @return null
 615          */
 616         public function getCount1() {
 617                 $this->set_fieldModifier('COUNT(%s)', $this->id);
 618                 $this->db->query($this->buildSql());
 619                 return $this->db->getScalar();
 620         }
 621
 622         public function getCount() {
 623                 // this is bad:
 624                 // it takes into account the counting rows in many2many table relationshit
 625                 // but it does not for more than one group by
 626                 foreach ($this->get_members() as $fieldName => $field) {
 627                         if ($field->get_group() == true) {
 628                                 $what = 'DISTINCT(' . $field->table .'.' . $fieldName . ')';
 629                         }
 630                 }
 631
 632                 if (empty ($what))
 633                         $what = '*';
 634
 635                 // made it a bit more clean and less sql portable by adding hard coded
 636                 // MY SQL stuff
 637                 $sql = $this->db->_SELECT (' COUNT(' . $what . ') ');
 638
 639                 $sql .= $this->db->_FROM( $this->name. $this->db->_AS($this->alias) );
 640
 641                 $this->buildInherentWheres();
 642
 643                 $sql .= $this->outputRefers();
 644
 645                 $sql .= $this->db->_WHERE ($this->outputWheres());
 646
 647                 // this would need to be replaced with a count(distinct(group by column))
 648                 // because we're using many2many relations
 649                 // also I do not know how this behaves for:
 650                 // 1. multiple group by's
 651                 // 2. !many2many relations.
 652 //              $sql .= $this->db->_GROUP ($this->outputGroups());
 653
 654                 $this->db->query($sql);
 655                 return $this->db->getScalar();
 656         }
 657
 658         public function getVector() {
 659                 // I really don't see why we need this. ?
 660         }
 661
 662         /**
 663          * Function to load the values of current object from an array
 664          * of type field_name => field_value
 665          * If strict is false, the current object can have fields that are not already
 666          * present in $this->fields[]
 667          *
 668          * @param array $valArray
 669          * @param bool $strict
 670          */
 671         public function loadFromArray ($valArray, $strict = true) {
 672                 foreach ($valArray as $fieldName => $value) {
 673                         if (array_key_exists ($fieldName, $this->fields)) {
 674                                 $this->fields[$fieldName]->set_value($value);
 675                         } elseif (!$strict) {
 676                                 // if the field name is not in the field list of the current object
 677                                 // it means that the valArray object is got from an JOIN sql
 678                                 $this->fields[$fieldName] = new tdoAbstractField ($value,'j1');
 679                                 $this->fields[$fieldName]->set_value ($value);
 680                         }
 681                 }
 682         }
 683
 684         /**
 685          * FIXME: make it work when composing with the same object
 686          *
 687          * @param tdoAbstract $incOb
 688          * @return void
 689          */
 690         private function composeObj ($incOb) {
 691                 if (!($incOb instanceof tdoAbstract))
 692                         return false;
 693                 $refs           = count($this->refers);
 694
 695                 foreach ($incOb->refers as $alias => $ref) {
 696                         $tAl                            = $refs++;
 697
 698                         $this->refers[$tAl]     = $ref;//str_replace(array($alias, $aliases[$alias][1]), array($tAl, $aliases[$alias][2]), $ref);
 699                         $this->refers[$tAl]->set_state ($tAl);
 700                 }
 701         }
 702
 703         /**
 704          * Function to execute a join between two tdoAbstract objects
 705          *
 706          * @param string $jType
 707          * @param tdoAbstractField $thisJField
 708          * @param tdoAbstract $incOb
 709          * @param tdoAbstractField $incObJField
 710          * @return unknown
 711          */
 712         public function joinWith ($jType = null, &$thisJField = null, &$incOb = null, &$incObJField = null) {
 713                 if (
 714                         !tdoAbstractJoin::isValidType ($jType) ||
 715                         !$this->isValidMember ($thisJField)
 716                 ) return false;
 717
 718                 $this->composeObj ($incOb);
 719
 720                 $tAl = (count($this->refers));
 721                 if ($tAl > 59) {
 722                         trigger_error('Join aborted for table '.$this->name.': Too many tables; MySQL can only use 61 tables in a join', E_USER_NOTICE);
 723                         return;
 724                 } else {
 725                         $incOb->set_alias($tAl);
 726
 727                         if($thisJField == null || !($thisJField instanceof tdoAbstractField))
 728                                 $thisJField = $this->id;
 729
 730                         if($incObJField == null || !($incObJField instanceof tdoAbstractField))
 731                                 $incObJField = $incOb->id;
 732
 733                         $this->refers[$tAl]     = new tdoAbstractJoin ($jType, $this, $incOb, $thisJField, $incObJField, $tAl);
 734                         $this->refers[$tAl]->set_state ($tAl);
 735                 }
 736 //              var_dump ($this->refers);
 737         }
 738
 739         /**
 740          * function to dump a <type>Sql
 741          * problem with the field types. :D
 742          *
 743          * @param tdoAbstract $obj
 744          *
 745          static public function dumpSchema ($obj) {
 746                 if ($obj instanceof tdoAbstract)
 747                 throw new Exception('Can\'t generate sql dump');
 748
 749                 $sql = 'CREATE TABLE '. $obj->name . ' (';
 750
 751                 foreach ($obj->getFields() as $fieldName => $data) {
 752                 $sql .= $fieldName.' '.$data[0].', ';
 753                 }
 754                 $sql .= ')';
 755                 return $sql;
 756                 }
 757                 */
 758 }
 759
 760 /**
 761  * class to abstract a where clause in a SQL query
 762  * TODO: add possibility of complex wheres: (t1 condition1 OR|AND|XOR t2.condition2)
 763  * TODO: abstract the condition part of a where clause - currently string based :D
 764  */
 765 class tdoAbstractClause {
 766         protected       $subject, $predicate, $predicative;
 767
 768         /**
 769          * initializing a WHERE|ON clause
 770          *
 771          * @param tdoAbstractClause|tdoAbstractField $subject
 772          * @param string $predicate
 773          * @param tdoAbstractClause|tdoAbstractField|null $complement
 774          */
 775         public function __construct ($subject, $predicate = null, $predicative = null) {
 776                 // I must be careful with the $subject == 1 because (int)object == 1
 777                 if (($subject === 1 || is_string($subject)) && $predicate == null && $predicative == null) {
 778                         $this->subject          = $subject;
 779                         $this->predicate        = '';
 780                         $this->predicative      = '';
 781                         return;
 782                 }
 783
 784                 if (($subject instanceof tdoAbstractField ) || ($subject instanceof tdoAbstractClause )) {
 785                         $this->subject          = &$subject;
 786
 787                         $subject->set_where = true;
 788
 789                         $this->predicative      = &$predicative;
 790
 791                         if ($this->validPredicative ($predicate))
 792                         $this->predicate        = $predicate;
 793
 794                 } else {
 795                         $this->subject          = '';
 796                         $this->predicate        = '';
 797                         $this->predicative      = '';
 798
 799                         return;
 800                 }
 801         }
 802         public function __destruct () {}
 803
 804         public function __toString () {
 805 //              var_dump($this->subject, $this->predicate, $this->predicative);
 806 //              echo '<br/>';
 807                 if ($this->subject === '1' || is_string($this->subject)) {
 808 //                      var_dump($this->subject);
 809                         return (string)$this->subject;
 810                 } elseif ($this->subject instanceof tdoAbstractClause) {
 811                         $subStr = (string)$this->subject;
 812                 } elseif ($this->subject instanceof tdoAbstractField) {
 813                         // without $this->subject->table != 't' we have a bug in the delete op
 814                         $subStr =  ($this->subject->table != 't' ? $this->subject->table.'.': '').$this->subject->name;
 815                 } else {
 816                         return '';
 817                 }
 818
 819                 if (is_null($this->predicative)) {
 820                         if ($this->validPredicative ($this->predicate)) {
 821                                 $preStr = 'NULL';
 822                         } else
 823                         $preStr = '';
 824                 } elseif (is_numeric($this->predicative)) {
 825                         $preStr = $this->predicative;
 826                 } elseif (is_string($this->predicative)) {
 827                         $preStr = $this->predicative;
 828
 829                         if ($this->predicate == 'LIKE') {
 830                                 $preStr = '%'.$this->predicate.'%';
 831                         }
 832
 833                         $preStr = (stripos($preStr, '"') !== 0 ? '"'.$preStr.'"' : $preStr);//'"'.$preStr.'"';
 834                 } elseif (is_array($this->predicative)) {
 835                         $preStr =  '("'.implode('", "',$this->predicative).'")';
 836                 } elseif ($this->predicative instanceof tdoAbstractfield) {
 837                         $preStr = ($this->predicative->table != 't' ? $this->predicative->table.'.': '').$this->predicative->name;
 838                 } elseif ($this->predicative instanceof tdoAbstractClause) {
 839                         $subStr = $subStr;
 840                         $preStr = $this->predicative;
 841                 }
 842
 843                 $retStr = $subStr.' '.$this->predicate.' '.$preStr;
 844                 if (($this->subject instanceof tdoAbstractClause) && ($this->predicative instanceof tdoAbstractClause))
 845                 return '('.$retStr.')';
 846
 847                 return $retStr;
 848         }
 849
 850         private function validPredicative ($predicate) {
 851                 // need to find a way to abstract these
 852                 //              $validPredicates = array (
 853                 //                      'AND',
 854                 //                      '&&',
 855                 //                      'OR',
 856                 //                      '||',
 857                 //                      'XOR',
 858                 //                      'IS',
 859                 //                      'IS NOT',
 860                 //                      '!',
 861                 //                      'IN',
 862                 //                      'LIKE',
 863                 //                      '=',
 864                 //                      '!=',
 865                 //                      '<>'
 866                 //              );
 867                 if ($this->predicative instanceof tdoAbstractClause) {
 868                         // we'll have Subject AND|OR|XOR Predicative
 869                         $validPredicates = array (
 870                                 'AND',
 871                                 '&&',
 872                                 'OR',
 873                                 '||',
 874                                 'XOR'
 875                                 );
 876                 } elseif (($this->predicative instanceof tdoAbstractField) || is_numeric($this->predicative)) {
 877                         // we'll have Subject =|!= Predicative
 878                         $validPredicates = array (
 879                                 '=',
 880                                 '!=',
 881                                 '>',
 882                                 '<',
 883                                 '>=',
 884                                 '<='
 885                                 );
 886                 } elseif (is_array($this->predicative)) {
 887                         $validPredicates = array (
 888                                 'IN',
 889                                 'NOT IN'
 890                                 );
 891                 } elseif (is_string($this->predicative)) {
 892                         $validPredicates = array (
 893                                 '=',
 894                                 'LIKE',
 895                         // dates
 896                                 '>',
 897                                 '<',
 898                                 '>=',
 899                                 '<='
 900                                 );
 901                 } elseif (is_null($this->predicative)) {
 902                         $validPredicates = array (
 903                                 'IS',
 904                                 'IS NOT'
 905                                 );
 906                 }
 907
 908                 return in_array($predicate, $validPredicates);
 909                 //
 910                 //              if (in_array($predicate, $validPredicates) && (($predicative instanceof tdoAbstractClause) || ($predicative instanceof tdoAbstractField)))
 911                 //                      return true;
 912                 //              return false;
 913         }
 914 }
 915
 916 class tdoAbstractJoin {
 917         static public $validTypes = array (
 918                 'INNER',
 919                 'LEFT',
 920                 'RIGHT',
 921                 'OUTER'
 922                 );
 923                 protected       $state,
 924                 $type,
 925
 926                 $leftTable,
 927                 $rightTable,
 928
 929                 $leftField,
 930                 $rightField;
 931
 932                 public function __construct ($type, &$lt, &$rt, &$lf, &$rf, $state) {
 933                         if ($rt instanceof tdoAbstract ||
 934                         $lt instanceof tdoAbstract
 935                         ) {
 936                                 $this->leftTable        = &$lt;
 937                                 $this->rightTable       = &$rt;
 938                         }
 939                         if (tdoAbstractJoin::isValidType($type))
 940                         $this->type = $type;
 941
 942                         if (
 943                         $lf instanceof tdoAbstractField &&
 944                         $rf instanceof tdoAbstractField
 945                         ) {
 946                                 $this->rightField       = &$rf;
 947                                 $this->leftField        = &$lf;
 948                         }
 949
 950                         $this->state    = $state;
 951
 952
 953                         $this->composeFields ();
 954                         $this->composeWheres ();
 955
 956                 }
 957
 958                 public function __destruct () {}
 959
 960                 public function __toString() {
 961                         $lAlias = $this->leftTable->get_alias();
 962
 963                         return (string)$this->type.' JOIN '.$this->rightTable->get_name().
 964                                 ' AS t'.$this->state.' ON '.(isset($lAlias) ? $lAlias : $this->leftTable->get_name()).
 965                                 '.'.$this->leftField->name.
 966                                 ' = t'.$this->state.'.'.$this->rightField->name.' ';
 967                 }
 968
 969                 /**
 970                  * Will compose the $rightTable and $leftTable fields
 971                  * @return void
 972                  */
 973                 public function composeFields () {
 974                         $leftFields             = $this->leftTable->get_members();
 975
 976                         $this->rightTable->set_alias($this->state);
 977                         $rightFields    = $this->rightTable->get_members();
 978
 979
 980                         $this->leftTable->addFields($rightFields);
 981                 }
 982
 983                 /**
 984                  * Will compose the $rightTable and $leftTable WHERE clauses
 985                  * @return void
 986                  */
 987                 public function composeWheres () {
 988                         if (!is_array($this->leftTable->wheres))
 989                         $this->leftTable->wheres =  array();
 990                         if (!is_array($this->rightTable->wheres))
 991                         $this->rightTable->wheres =  array();
 992
 993                         //              var_dump($this->rightTable->wheres, $this->leftTable );die;
 994                         foreach ($this->rightTable->wheres as $where) {
 995                                 $this->leftTable->addWhere ($where);
 996                         }
 997                         $this->leftTable->wheres = array_merge($this->rightTable->wheres, $this->leftTable->wheres);
 998                 }
 999
1000                 public function set_state ($st) {
1001                         $this->state    = $st;
1002                 }
1003
1004                 static public function isValidType ($inc) {
1005                         if (in_array($inc, tdoAbstractJoin::$validTypes))
1006                         return true;
1007                         return false;
1008                 }
1009 }
1010
1011 define ('INDEX',        1);
1012 define ('PRIMARY',      2);
1013 define ('UNIQUE',       4);
1014 define ('FULLTEXT',     8);
1015
1016 class tdoAbstractField {
1017         static public $validTypes = array (
1018                 'VARCHAR',
1019                 'INT',
1020                 'DATE',
1021                 'TEXT',
1022                 'FLOAT',
1023                 'TIMESTAMP',
1024                 'ENUM'
1025                 );
1026
1027                 protected       $name, $type, $flags, $value, $table, $modifier = null, $order = null, $group = null, $where = false;
1028
1029                 public function __construct ($incName, $incTable, $incType='INT', $incFlags=0) {
1030                         $this->name             = $incName;
1031                         $this->table    = $incTable;
1032                         $this->type             = $incType;
1033                         $this->flags    = $incFlags;
1034                 }
1035
1036                 public function __set ( $key, $value ) {
1037                         if ( array_key_exists ($key, get_object_vars($this)) ) {
1038                                 $this->$key = $value;
1039
1040                                 //                      if ($key == 'where')
1041                                 //                              var_dump($this);
1042
1043                                 if ( is_null ($this->type) )
1044                                 $this->setType();
1045
1046                                 return true;
1047                         } else
1048                         return false;
1049                 }
1050
1051                 public function __get ( $key ) {
1052                         return $this->$key;
1053                 }
1054
1055                 public function __call ( $method, $args) {
1056                         $all = get_object_vars($this);
1057
1058                         if ( preg_match( '/set_(.*)/', $method, $found ) ) {
1059                                 if  (array_key_exists( $found[1], $all)){
1060                                         $this->$found[1] = $args[0];
1061                                         return true;
1062                                 }
1063                         } elseif ( preg_match( '/get_(.*)/', $method, $found ) ) {
1064                                 if  (array_key_exists( $found[1], $all)){
1065                                         return $this->$found[1];
1066                                 }
1067                         }
1068                         return false;
1069                 }
1070
1071                 public function __destruct () {}
1072
1073                 public function __toString () {
1074                         return (string)$this->value;
1075                 }
1076
1077                 //      public function inWhere () {
1078                 //              return $this->where;
1079                 //      }
1080
1081                 static public function isValidType ($inc) {
1082                         if (in_array($inc, tdoAbstractField::$validTypes)){
1083                                 return true;
1084                         }
1085                         return false;
1086                 }
1087
1088                 public function set_modifier ($modif) {
1089                         //              if (stristr($modif, '%'))
1090                         $this->modifier = $modif;
1091                 }
1092
1093                 public function set_value ($value) {
1094                         $this->value = $value;
1095                 }
1096
1097                 public function set_group ($true = true) {
1098                         $this->group = (bool)$true;
1099                 }
1100
1101                 public function set_order ($asc = true) {
1102                         $this->order = (bool)$asc;
1103                 }
1104
1105                 public function isIndex() {
1106                         return (($this->flags & INDEX) == INDEX);
1107                 }
1108
1109                 public function isPrimary() {
1110                         return (($this->flags & PRIMARY) == PRIMARY);
1111                 }
1112
1113                 public function isFullText() {
1114                         return (($this->flags & FULLTEXT) == FULLTEXT);
1115                 }
1116                 public function isUnique () {
1117                         return (($this->flags & UNIQUE) == UNIQUE);
1118                 }
1119                 public function setType () {
1120                         $incValue = $this->value;
1121                         // TODO : enums
1122                         if (is_int($incValue)) {
1123                                 $this->type = 'INT';
1124                         } elseif (is_float($incValue)) {
1125                                 $this->type = 'FLOAT';
1126                         } elseif (is_string($incValue)) {
1127                                 if (strtotime($this->value)){
1128                                         $this->type = 'DATE';
1129                                 }elseif (strlen($incValue) > 255)
1130                                 $this->type = 'TEXT';
1131                                 else
1132                                 $this->type = 'VARCHAR';
1133                         }
1134                 }
1135 }