[Sommaire] [Imprimer]

   1  <?php
   2  
   3  /*
   4   *  $Id: PHP5ComplexPeerBuilder.php 227 2005-10-09 14:00:40Z david $
   5   *
   6   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   7   * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   8   * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   9   * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  10   * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  11   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  12   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  13   * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  14   * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  15   * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  16   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  17   *
  18   * This software consists of voluntary contributions made by many individuals
  19   * and is licensed under the LGPL. For more information please see
  20   * <http://propel.phpdb.org>.
  21   */
  22  
  23  require_once 'propel/engine/builder/om/php5/PHP5BasicPeerBuilder.php';
  24  
  25  /**
  26   * Generates a PHP5 base Peer class with complex object model methods.
  27   * 
  28   * This class extends the basic peer builder by adding on the doSelectJoin*()
  29   * methods and other complex object model methods.
  30   * 
  31   * @author Hans Lellelid <hans@xmpl.org>
  32   * @package propel.engine.builder.om.php5
  33   */
  34  class PHP5ComplexPeerBuilder extends PHP5BasicPeerBuilder {        
  35  
  36      /**
  37       * Adds the complex OM methods to the base addSelectMethods() function.
  38       * @param string &$script The script will be modified in this method.
  39       * @see PeerBuilder::addSelectMethods()
  40       */
  41  	protected function addSelectMethods(&$script)
  42      {
  43          $table = $this->getTable();
  44          
  45          parent::addSelectMethods($script);
  46  
  47          $this->addDoCountJoin($script);
  48          $this->addDoSelectJoin($script);
  49          
  50          $countFK = count($table->getForeignKeys());
  51          
  52          $includeJoinAll = true;
  53          
  54          foreach ($this->getTable()->getForeignKeys() as $fk) {
  55              $tblFK = $table->getDatabase()->getTable($fk->getForeignTableName());
  56              if ($tblFK->isForReferenceOnly()) {
  57                 $includeJoinAll = false;
  58              }
  59          }
  60  
  61          if ($includeJoinAll) {
  62              if($countFK > 0) {
  63                  $this->addDoCountJoinAll($script);
  64                  $this->addDoSelectJoinAll($script);
  65              }
  66              if ($countFK > 1) {
  67                  $this->addDoCountJoinAllExcept($script);
  68                  $this->addDoSelectJoinAllExcept($script);
  69              }
  70          }
  71          
  72      }
  73      
  74      /**
  75       * Adds the doSelectJoin*() methods.
  76       * @param string &$script The script will be modified in this method.
  77       */
  78  	protected function addDoSelectJoin(&$script)
  79      {
  80          $table = $this->getTable();
  81          $className = $table->getPhpName();
  82          $countFK = count($table->getForeignKeys());
  83          
  84          if ($countFK >= 1) {
  85          
  86              foreach ($table->getForeignKeys() as $fk) {
  87              
  88                  $joinTable = $table->getDatabase()->getTable($fk->getForeignTableName());
  89                  
  90                  if (!$joinTable->isForReferenceOnly()) {
  91                  
  92                      // FIXME - look into removing this next condition; it may not
  93                      // be necessary:
  94                      // --- IT is necessary because there needs to be a system for 
  95                      // aliasing the table if it is the same table.
  96                      if ( $fk->getForeignTableName() != $table->getName() ) {
  97                          
  98                          /*
  99                          REPLACED BY USING THE ObjectBuilder objects below
 100                          
 101                          // check to see if we need to add something to the method name.
 102                          // For example if there are multiple columns that reference the same
 103                          // table, then we have to have a methd name like doSelectJoinBooksByBookId
 104                          $partJoinName = "";
 105                          foreach ($fk->getLocalColumns() as $columnName ) {
 106                              $column = $table->getColumn($columnName);
 107                                  //                            this second part is not currently ever true (right?)
 108                              if ($column->isMultipleFK() || $fk->getForeignTableName() == $table->getName()) {
 109                                  $partJoinName = $partJoinName . $column->getPhpName();
 110                              }
 111                          }
 112                          
 113                          
 114                          $joinClassName = $joinTable->getPhpName();
 115                          
 116                          if ($joinTable->getInterface()) {
 117                             $interfaceName = $joinTable->getInterface();
 118                          } else {
 119                              $interfaceName = $joinTable->getPhpName();
 120                          }
 121          
 122                          if ($partJoinName == "") {
 123                              $joinColumnId = $joinClassName;
 124                              $joinInterface = $interfaceName;
 125                              $collThisTable = $className . "s";
 126                              $collThisTableMs = $className;
 127                          } else {
 128                              $joinColumnId = $joinClassName . "RelatedBy" . $partJoinName;
 129                              $joinInterface = $interfaceName . "RelatedBy" . $partJoinName;
 130                              $collThisTable = $className . "sRelatedBy" . $partJoinName;
 131                              $collThisTableMs = $className . "RelatedBy" . $partJoinName;
 132                          }
 133                          */
 134                          
 135                          $joinClassName = $joinTable->getPhpName();
 136                          
 137                          $thisTableObjectBuilder = OMBuilder::getNewObjectBuilder($table);
 138                          $joinedTableObjectBuilder = OMBuilder::getNewObjectBuilder($joinTable);
 139                          $joinedTablePeerBuilder = OMBuilder::getNewPeerBuilder($joinTable);
 140                          
 141                          $script .= "
 142  
 143      /**
 144       * Selects a collection of $className objects pre-filled with their $joinClassName objects.
 145       *
 146       * @return array Array of $className objects.
 147       * @throws PropelException Any exceptions caught during processing will be
 148       *         rethrown wrapped into a PropelException.
 149       */
 150  	public static function doSelectJoin".$thisTableObjectBuilder->getFKPhpNameAffix($fk, $plural = false)."(Criteria \$c, \$con = null)
 151      {
 152          \$c = clone \$c;
 153  
 154          // Set the correct dbName if it has not been overridden
 155          if (\$c->getDbName() == Propel::getDefaultDB()) {
 156              \$c->setDbName(self::DATABASE_NAME);
 157          }
 158  
 159          ".$this->getPeerClassname()."::addSelectColumns(\$c);
 160          \$startcol = (".$this->getPeerClassname()."::NUM_COLUMNS - ".$this->getPeerClassname()."::NUM_LAZY_LOAD_COLUMNS) + 1;
 161          ".$joinedTablePeerBuilder->getPeerClassname()."::addSelectColumns(\$c);
 162  ";
 163          
 164                          $lfMap = $fk->getLocalForeignMapping();
 165                          foreach ($fk->getLocalColumns() as $columnName ) {
 166                              $column = $table->getColumn($columnName);
 167                              $columnFk = $joinTable->getColumn( $lfMap[$columnName] );
 168                              $script .= "
 169          \$c->addJoin(".$this->getColumnConstant($column).", ".$joinedTablePeerBuilder->getColumnConstant($columnFk).");"; //CHECKME
 170                          }
 171                          $script .= "
 172          \$rs = ".$this->basePeerClassname."::doSelect(\$c, \$con);
 173          \$results = array();
 174  
 175          while(\$rs->next()) {
 176  ";
 177                          if ($table->getChildrenColumn()) {
 178                              $script .= "
 179              \$omClass = ".$this->getPeerClassname()."::getOMClass(\$rs, 1);
 180  ";
 181                          } else {
 182                              $script .= "
 183              \$omClass = ".$this->getPeerClassname()."::getOMClass();
 184  ";
 185                          } 
 186                          $script .= "
 187              \$cls = Propel::import(\$omClass);
 188              \$obj1 = new \$cls();
 189              \$obj1->hydrate(\$rs);
 190  ";
 191                          if ($joinTable->getChildrenColumn()) {
 192                              $script .= "
 193              \$omClass = ".$joinedTablePeerBuilder->getPeerClassname()."::getOMClass(\$rs, \$startcol);
 194  ";
 195                          } else { 
 196                              $script .= "
 197              \$omClass = ".$joinedTablePeerBuilder->getPeerClassname()."::getOMClass();
 198  ";
 199                          }
 200                          
 201                          $script .= "
 202              \$cls = Propel::import(\$omClass);
 203              \$obj2 = new \$cls();
 204              \$obj2->hydrate(\$rs, \$startcol);
 205  
 206              \$newObject = true;
 207              foreach(\$results as \$temp_obj1) {
 208                  \$temp_obj2 = \$temp_obj1->get".$thisTableObjectBuilder->getFKPhpNameAffix($fk, $plural = false)."(); //CHECKME
 209                  if (\$temp_obj2->getPrimaryKey() === \$obj2->getPrimaryKey()) {
 210                      \$newObject = false;
 211                      // e.g. \$author->addBookRelatedByBookId()
 212                      \$temp_obj2->add".$joinedTableObjectBuilder->getRefFKPhpNameAffix($fk, $plural = false)."(\$obj1); //CHECKME
 213                      break;
 214                  }
 215              }
 216              if (\$newObject) {
 217                  \$obj2->init".$joinedTableObjectBuilder->getRefFKPhpNameAffix($fk, $plural = true)."();
 218                  \$obj2->add".$joinedTableObjectBuilder->getRefFKPhpNameAffix($fk, $plural = false)."(\$obj1); //CHECKME
 219              }
 220              \$results[] = \$obj1;
 221          }
 222          return \$results;
 223      }
 224  ";
 225                      } // if fk table name != this table name
 226                  } // if ! is reference only
 227              } // foreach column
 228          } // if count(fk) > 1
 229          
 230      } // addDoSelectJoin()
 231      
 232      /**
 233       * Adds the doCountJoin*() methods.
 234       * @param string &$script The script will be modified in this method.
 235       */
 236  	protected function addDoCountJoin(&$script)
 237      {
 238          $table = $this->getTable();
 239          $className = $table->getPhpName();
 240          $countFK = count($table->getForeignKeys());
 241          
 242          if ($countFK >= 1) {
 243          
 244              foreach ($table->getForeignKeys() as $fk) {
 245              
 246                  $joinTable = $table->getDatabase()->getTable($fk->getForeignTableName());
 247                  
 248                  if (!$joinTable->isForReferenceOnly()) {
 249                  
 250                      if ( $fk->getForeignTableName() != $table->getName() ) {
 251                          
 252                          $joinClassName = $joinTable->getPhpName();
 253                          
 254                          $thisTableObjectBuilder = OMBuilder::getNewObjectBuilder($table);
 255                          $joinedTableObjectBuilder = OMBuilder::getNewObjectBuilder($joinTable);
 256                          $joinedTablePeerBuilder = OMBuilder::getNewPeerBuilder($joinTable);
 257                          
 258                          $script .= "
 259  
 260      /**
 261       * Returns the number of rows matching criteria, joining the related ".$thisTableObjectBuilder->getFKPhpNameAffix($fk, $plural = false)." table
 262       *
 263       * @param Criteria \$c
 264       * @param boolean \$distinct Whether to select only distinct columns (You can also set DISTINCT modifier in Criteria).
 265       * @param Connection \$con
 266       * @return int Number of matching rows.
 267       */
 268  	public static function doCountJoin".$thisTableObjectBuilder->getFKPhpNameAffix($fk, $plural = false)."(Criteria \$criteria, \$distinct = false, \$con = null)
 269      {
 270          // we're going to modify criteria, so copy it first
 271          \$criteria = clone \$criteria;
 272          
 273          // clear out anything that might confuse the ORDER BY clause
 274          \$criteria->clearSelectColumns()->clearOrderByColumns();
 275          if (\$distinct || in_array(Criteria::DISTINCT, \$criteria->getSelectModifiers())) {
 276              \$criteria->addSelectColumn(".$this->getPeerClassname()."::COUNT_DISTINCT);
 277          } else {
 278              \$criteria->addSelectColumn(".$this->getPeerClassname()."::COUNT);
 279          }
 280          
 281          // just in case we're grouping: add those columns to the select statement
 282          foreach(\$criteria->getGroupByColumns() as \$column)
 283          {
 284              \$criteria->addSelectColumn(\$column);
 285          }
 286  ";
 287                          $lfMap = $fk->getLocalForeignMapping();
 288                          foreach ($fk->getLocalColumns() as $columnName ) {
 289                              $column = $table->getColumn($columnName);
 290                              $columnFk = $joinTable->getColumn( $lfMap[$columnName] );
 291                              $script .= "
 292          \$criteria->addJoin(".$this->getColumnConstant($column).", ".$joinedTablePeerBuilder->getColumnConstant($columnFk).");
 293  ";
 294                          }
 295                          $script .= "
 296          \$rs = ".$this->getPeerClassname()."::doSelectRS(\$criteria, \$con);
 297          if (\$rs->next()) {
 298              return \$rs->getInt(1);
 299          } else {
 300              // no rows returned; we infer that means 0 matches.
 301              return 0;
 302          }
 303      }
 304  ";
 305                      } // if fk table name != this table name
 306                  } // if ! is reference only
 307              } // foreach column
 308          } // if count(fk) > 1
 309          
 310      } // addDoCountJoin()
 311      
 312      /**
 313       * Adds the doSelectJoinAll() method.
 314       * @param string &$script The script will be modified in this method.
 315       */
 316  	protected function addDoSelectJoinAll(&$script)
 317      {
 318          $table = $this->getTable();
 319          $className = $table->getPhpName();
 320          
 321          $script .= "
 322  
 323      /**
 324       * Selects a collection of $className objects pre-filled with all related objects.
 325       *
 326       * @return array Array of $className objects.
 327       * @throws PropelException Any exceptions caught during processing will be
 328       *         rethrown wrapped into a PropelException.
 329       */
 330  	public static function doSelectJoinAll(Criteria \$c, \$con = null)
 331      {
 332          \$c = clone \$c;
 333  
 334          // Set the correct dbName if it has not been overridden
 335          if (\$c->getDbName() == Propel::getDefaultDB()) {
 336              \$c->setDbName(self::DATABASE_NAME);
 337          }
 338  
 339          ".$this->getPeerClassname()."::addSelectColumns(\$c);
 340          \$startcol2 = (".$this->getPeerClassname()."::NUM_COLUMNS - ".$this->getPeerClassname()."::NUM_LAZY_LOAD_COLUMNS) + 1;
 341  ";
 342          $index = 2;
 343          foreach ($table->getForeignKeys() as $fk) {
 344              // want to cover this case, but the code is not there yet.
 345              // FIXME: why "is the code not there yet" ?
 346              if ( $fk->getForeignTableName() != $table->getName() ) {
 347                  $joinTable = $table->getDatabase()->getTable($fk->getForeignTableName());
 348                  $joinClassName = $joinTable->getPhpName();
 349                  $new_index = $index + 1;
 350                  
 351                  $joinedTablePeerBuilder = OMBuilder::getNewPeerBuilder($joinTable);
 352                          
 353                  $script .= "
 354          ".$joinedTablePeerBuilder->getPeerClassname()."::addSelectColumns(\$c);
 355          \$startcol$new_index = \$startcol$index + ".$joinedTablePeerBuilder->getPeerClassname()."::NUM_COLUMNS;
 356  ";
 357              $index = $new_index;
 358              
 359              } // if fk->getForeignTableName != table->getName        
 360          } // foreach [sub] foreign keys
 361  
 362  
 363          foreach ($table->getForeignKeys() as $fk) {
 364              // want to cover this case, but the code is not there yet.
 365              if ( $fk->getForeignTableName() != $table->getName() ) {
 366                  $joinTable = $table->getDatabase()->getTable($fk->getForeignTableName());
 367                  $joinedTablePeerBuilder = OMBuilder::getNewPeerBuilder($joinTable);
 368                  
 369                  $joinClassName = $joinTable->getPhpName();
 370                  $lfMap = $fk->getLocalForeignMapping();
 371                  foreach ($fk->getLocalColumns() as $columnName ) {
 372                      $column = $table->getColumn($columnName);
 373                      $columnFk = $joinTable->getColumn( $lfMap[$columnName]);
 374                      $script .= "
 375          \$c->addJoin(".$this->getColumnConstant($column).", ".$joinedTablePeerBuilder->getColumnConstant($columnFk).");
 376  ";
 377                    } 
 378              } 
 379          }
 380          
 381          $script .= "
 382          \$rs = ".$this->basePeerClassname."::doSelect(\$c, \$con);
 383          \$results = array();
 384          
 385          while(\$rs->next()) {
 386  ";
 387  
 388          if ($table->getChildrenColumn()) { 
 389              $script .= "
 390              \$omClass = ".$this->getPeerClassname()."::getOMClass(\$rs, 1);
 391  ";
 392          } else {
 393              $script .= "
 394              \$omClass = ".$this->getPeerClassname()."::getOMClass();
 395  ";
 396          }
 397      
 398          $script .= "
 399              
 400              \$cls = Propel::import(\$omClass);
 401              \$obj1 = new \$cls();
 402              \$obj1->hydrate(\$rs);
 403  ";
 404  
 405          $index = 1;
 406          foreach ($table->getForeignKeys() as $fk ) {
 407              
 408              // want to cover this case, but the code is not there yet.
 409              // FIXME -- why not? -because we'd have to alias the tables in the JOIN
 410              if ( $fk->getForeignTableName() != $table->getName() ) {
 411                  
 412                  $joinTable = $table->getDatabase()->getTable($fk->getForeignTableName());
 413                  $joinClassName = $joinTable->getPhpName();
 414                  $interfaceName = $joinTable->getPhpName();
 415                  if($joinTable->getInterface()) {
 416                      $interfaceName = $joinTable->getInterface();
 417                  }
 418                  
 419                  /*
 420                  $partJoinName = "";
 421                  foreach ($fk->getLocalColumns() as $columnName ) {
 422                      $column = $table->getColumn($columnName);
 423                      if ($column->isMultipleFK()) {
 424                          $partJoinName .= $column->getPhpName();
 425                      }
 426                  }
 427                  
 428                  if ($partJoinName == "") {
 429                      $joinString = $interfaceName;
 430                      $collThisTable = "${className}s";
 431                      $collThisTableMs = $className;
 432                  } else {
 433                      $joinString= $interfaceName."RelatedBy" . $partJoinName;
 434                      $collThisTable= $className . "sRelatedBy" . $partJoinName;
 435                      $collThisTableMs= $className . "RelatedBy" . $partJoinName;
 436                  }
 437                  */
 438                  
 439                  $thisTableObjectBuilder = OMBuilder::getNewObjectBuilder($table);
 440                  $joinedTableObjectBuilder = OMBuilder::getNewObjectBuilder($joinTable);
 441                  $joinedTablePeerBuilder = OMBuilder::getNewPeerBuilder($joinTable);
 442                  
 443                  
 444                  $index++;
 445                  
 446                  $script .= "
 447                  
 448                  // Add objects for joined $joinClassName rows
 449      ";
 450                  if ($joinTable->getChildrenColumn()) {
 451                      $script .= "
 452              \$omClass = ".$joinedTablePeerBuilder->getPeerClassname()."::getOMClass(\$rs, \$startcol$index);
 453  ";
 454                  } else {
 455                      $script .= "
 456              \$omClass = ".$joinedTablePeerBuilder->getPeerClassname()."::getOMClass();
 457  ";
 458                  } /* $joinTable->getChildrenColumn() */
 459              
 460                  $script .= "
 461      
 462              \$cls = Propel::import(\$omClass);
 463              \$obj".$index." = new \$cls();
 464              \$obj".$index."->hydrate(\$rs, \$startcol$index);
 465              
 466              \$newObject = true;
 467              for (\$j=0, \$resCount=count(\$results); \$j < \$resCount; \$j++) {
 468                  \$temp_obj1 = \$results[\$j];
 469                  \$temp_obj$index = \$temp_obj1->get".$thisTableObjectBuilder->getFKPhpNameAffix($fk, $plural = false)."(); // CHECKME
 470                  if (\$temp_obj".$index."->getPrimaryKey() === \$obj".$index."->getPrimaryKey()) {
 471                      \$newObject = false;
 472                      \$temp_obj".$index."->add".$joinedTableObjectBuilder->getRefFKPhpNameAffix($fk, $plural = false)."(\$obj1); // CHECKME
 473                      break;
 474                  }
 475              }
 476              
 477              if (\$newObject) {
 478                  \$obj".$index."->init".$joinedTableObjectBuilder->getRefFKPhpNameAffix($fk, $plural = true)."();
 479                  \$obj".$index."->add".$joinedTableObjectBuilder->getRefFKPhpNameAffix($fk, $plural = false)."(\$obj1);
 480              }
 481  ";
 482  
 483              } // $fk->getForeignTableName() != $table->getName()
 484          } //foreach foreign key
 485          
 486          $script .= "
 487              \$results[] = \$obj1;
 488          }
 489          return \$results;
 490      }
 491  ";
 492      
 493      } // end addDoSelectJoinAll()
 494      
 495      /**
 496       * Adds the doCountJoinAll() method.
 497       * @param string &$script The script will be modified in this method.
 498       */
 499  	protected function addDoCountJoinAll(&$script)
 500      {
 501          $table = $this->getTable();
 502          $className = $table->getPhpName();
 503          
 504          $script .= "
 505  
 506      /**
 507       * Returns the number of rows matching criteria, joining all related tables
 508       *
 509       * @param Criteria \$c
 510       * @param boolean \$distinct Whether to select only distinct columns (You can also set DISTINCT modifier in Criteria).
 511       * @param Connection \$con
 512       * @return int Number of matching rows.
 513       */
 514  	public static function doCountJoinAll(Criteria \$criteria, \$distinct = false, \$con = null)
 515      {
 516          \$criteria = clone \$criteria;
 517  
 518          // clear out anything that might confuse the ORDER BY clause
 519          \$criteria->clearSelectColumns()->clearOrderByColumns();
 520          if (\$distinct || in_array(Criteria::DISTINCT, \$criteria->getSelectModifiers())) {
 521              \$criteria->addSelectColumn(".$this->getPeerClassname()."::COUNT_DISTINCT);
 522          } else {
 523              \$criteria->addSelectColumn(".$this->getPeerClassname()."::COUNT);
 524          }
 525          
 526          // just in case we're grouping: add those columns to the select statement
 527          foreach(\$criteria->getGroupByColumns() as \$column)
 528          {
 529              \$criteria->addSelectColumn(\$column);
 530          }
 531  ";
 532  
 533          foreach ($table->getForeignKeys() as $fk) {
 534              // want to cover this case, but the code is not there yet.
 535              if ( $fk->getForeignTableName() != $table->getName() ) {
 536                  $joinTable = $table->getDatabase()->getTable($fk->getForeignTableName());
 537                  $joinedTablePeerBuilder = OMBuilder::getNewPeerBuilder($joinTable);
 538                  
 539                  $joinClassName = $joinTable->getPhpName();
 540                  $lfMap = $fk->getLocalForeignMapping();
 541                  foreach ($fk->getLocalColumns() as $columnName ) {
 542                      $column = $table->getColumn($columnName);
 543                      $columnFk = $joinTable->getColumn( $lfMap[$columnName]);
 544                      $script .= "
 545          \$criteria->addJoin(".$this->getColumnConstant($column).", ".$joinedTablePeerBuilder->getColumnConstant($columnFk).");
 546  ";
 547                  }
 548              } // if fk->getForeignTableName != table->getName        
 549          } // foreach [sub] foreign keys
 550  
 551          $script .= "
 552          \$rs = ".$this->getPeerClassname()."::doSelectRS(\$criteria, \$con);
 553          if (\$rs->next()) {
 554              return \$rs->getInt(1);
 555          } else {
 556              // no rows returned; we infer that means 0 matches.
 557              return 0;
 558          }
 559      }
 560  ";
 561      } // end addDoCountJoinAll()
 562      
 563      /**
 564       * Adds the doSelectJoinAllExcept*() methods.
 565       * @param string &$script The script will be modified in this method.
 566       */
 567  	protected function addDoSelectJoinAllExcept(&$script)
 568      {
 569          $table = $this->getTable();
 570          
 571          // ------------------------------------------------------------------------
 572          // doSelectJoinAllExcept*()
 573          // ------------------------------------------------------------------------
 574          
 575          // 2) create a bunch of doSelectJoinAllExcept*() methods
 576          // -- these were existing in original Torque, so we should keep them for compatibility
 577          
 578          $fkeys = $table->getForeignKeys();  // this sep assignment is necessary otherwise sub-loops over 
 579                                              // getForeignKeys() will cause this to only execute one time.
 580          foreach ($fkeys as $fk ) {
 581              
 582              $tblFK = $table->getDatabase()->getTable($fk->getForeignTableName());
 583  
 584              $excludedTable = $table->getDatabase()->getTable($fk->getForeignTableName());
 585              $excludedClassName = $excludedTable->getPhpName();
 586              
 587              /*
 588              $relatedByCol = "";
 589              foreach ($fk->getLocalColumns() as $columnName) {
 590                  $column = $table->getColumn($columnName);
 591                  if ($column->isMultipleFK()) {
 592                      $relatedByCol .= $column->getPhpName();
 593                  }
 594              }
 595              
 596              if ($relatedByCol == "") {
 597                  $excludeString = $excludedClassName;
 598                  $collThisTable = "${className}s";
 599                  $collThisTableMs = $className;
 600              } else {
 601                  $excludeString = $excludedClassName . "RelatedBy" . $relatedByCol;
 602                  $collThisTable = $className . "sRelatedBy" . $relatedByCol;
 603                  $collThisTableMs = $className . "RelatedBy" . $relatedByCol;
 604              }
 605              */
 606              
 607              $thisTableObjectBuilder = OMBuilder::getNewObjectBuilder($table);
 608              $excludedTableObjectBuilder = OMBuilder::getNewObjectBuilder($excludedTable);
 609              $excludedTablePeerBuilder = OMBuilder::getNewPeerBuilder($excludedTable);
 610                  
 611          $script .= "
 612  
 613      /**
 614       * Selects a collection of ".$table->getPhpName()." objects pre-filled with all related objects except ".$thisTableObjectBuilder->getFKPhpNameAffix($fk).".
 615       *
 616       * @return array Array of ".$table->getPhpName()." objects.
 617       * @throws PropelException Any exceptions caught during processing will be
 618       *         rethrown wrapped into a PropelException.
 619       */
 620  	public static function doSelectJoinAllExcept".$thisTableObjectBuilder->getFKPhpNameAffix($fk, $plural = false)."(Criteria \$c, \$con = null)
 621      {
 622          \$c = clone \$c;
 623  
 624          // Set the correct dbName if it has not been overridden
 625          // \$c->getDbName() will return the same object if not set to another value
 626          // so == check is okay and faster
 627          if (\$c->getDbName() == Propel::getDefaultDB()) {
 628              \$c->setDbName(self::DATABASE_NAME);
 629          }
 630  
 631          ".$this->getPeerClassname()."::addSelectColumns(\$c);
 632          \$startcol2 = (".$this->getPeerClassname()."::NUM_COLUMNS - ".$this->getPeerClassname()."::NUM_LAZY_LOAD_COLUMNS) + 1;
 633  ";    
 634              $index = 2;
 635              foreach ($table->getForeignKeys() as $subfk) {
 636                  // want to cover this case, but the code is not there yet.
 637                  // FIXME - why not?
 638                  if ( !($subfk->getForeignTableName() == $table->getName())) {
 639                      $joinTable = $table->getDatabase()->getTable($subfk->getForeignTableName());
 640                      $joinClassName = $joinTable->getPhpName();
 641                      $joinTablePeerBuilder = OMBuilder::getNewPeerBuilder($joinTable);
 642          
 643                      if ($joinClassName != $excludedClassName) {
 644                          $new_index = $index + 1;
 645                          $script .= "
 646          ".$joinTablePeerBuilder->getPeerClassname()."::addSelectColumns(\$c);
 647          \$startcol$new_index = \$startcol$index + ".$joinTablePeerBuilder->getPeerClassname()."::NUM_COLUMNS;
 648  ";
 649                      $index = $new_index;
 650                      } // if joinClassName not excludeClassName 
 651                  } // if subfk is not curr table
 652              } // foreach [sub] foreign keys
 653                  
 654              foreach ($table->getForeignKeys() as $subfk) {
 655                  // want to cover this case, but the code is not there yet.
 656                  if ( $subfk->getForeignTableName() != $table->getName() ) {
 657                      $joinTable = $table->getDatabase()->getTable($subfk->getForeignTableName());
 658                      $joinClassName = $joinTable->getPhpName();
 659                      $joinTablePeerBuilder = OMBuilder::getNewPeerBuilder($joinTable);
 660  
 661                      if($joinClassName != $excludedClassName)
 662                      {
 663                          $lfMap = $subfk->getLocalForeignMapping();
 664                          foreach ($subfk->getLocalColumns() as $columnName ) {
 665                              $column = $table->getColumn($columnName);
 666                              $columnFk = $joinTable->getColumn( $lfMap[$columnName]);
 667                              $script .= "
 668          \$c->addJoin(".$this->getColumnConstant($column).", ".$joinTablePeerBuilder->getColumnConstant($columnFk).");
 669  ";
 670                          }
 671                      } 
 672                  }
 673              } // foreach fkeys 
 674              $script .= "
 675  
 676          \$rs = ".$this->basePeerClassname ."::doSelect(\$c, \$con);
 677          \$results = array();
 678          
 679          while(\$rs->next()) {
 680  ";
 681              if ($table->getChildrenColumn()) {
 682                  $script .= "
 683              \$omClass = ".$this->getPeerClassname()."::getOMClass(\$rs, 1);
 684  ";
 685              } else {
 686                  $script .= "
 687              \$omClass = ".$this->getPeerClassname()."::getOMClass();
 688  ";
 689              }
 690              
 691              $script .= "
 692              \$cls = Propel::import(\$omClass);
 693              \$obj1 = new \$cls();
 694              \$obj1->hydrate(\$rs);        
 695  ";
 696      
 697          $index = 1;
 698          foreach ($table->getForeignKeys() as $subfk ) {
 699            // want to cover this case, but the code is not there yet.
 700            if ( $subfk->getForeignTableName() != $table->getName() ) {
 701            
 702                  $joinTable = $table->getDatabase()->getTable($subfk->getForeignTableName());
 703                  $joinClassName = $joinTable->getPhpName();
 704                  $interfaceName = $joinTable->getPhpName();
 705                  if($joinTable->getInterface()) {
 706                      $interfaceName = $joinTable->getInterface();
 707                  }
 708      
 709                  if ($joinClassName != $excludedClassName) {
 710                      
 711                      /*
 712                      $partJoinName = "";
 713                      foreach ($subfk->getLocalColumns() as $columnName ) {
 714                          $column = $table->getColumn($columnName);
 715                          if ($column->isMultipleFK()) {
 716                              $partJoinName .= $column->getPhpName();
 717                          }
 718                      }
 719      
 720                      if ($partJoinName == "") {
 721                          $joinString = $interfaceName;
 722                          $collThisTable = "${className}s";
 723                          $collThisTableMs = $className;
 724                      } else {
 725                          $joinString= $interfaceName."RelatedBy" . $partJoinName;
 726                          $collThisTable= $className . "sRelatedBy" . $partJoinName;
 727                          $collThisTableMs= $className . "RelatedBy" . $partJoinName;
 728                      }
 729                      */
 730                      
 731                      $joinedTableObjectBuilder = OMBuilder::getNewObjectBuilder($joinTable);
 732                      $joinedTablePeerBuilder = OMBuilder::getNewPeerBuilder($joinTable);
 733                      
 734                      $index++;
 735                  
 736                      if ($joinTable->getChildrenColumn()) {
 737                          $script .= "
 738              \$omClass = ".$joinedTablePeerBuilder->getPeerClassname()."::getOMClass(\$rs, \$startcol$index);
 739  ";
 740                      } else {
 741                          $script .= "
 742              \$omClass = ".$joinedTablePeerBuilder->getPeerClassname()."::getOMClass();
 743  ";
 744                      } /* $joinTable->getChildrenColumn() */
 745      
 746                      $script .= "
 747      
 748              \$cls = Propel::import(\$omClass);
 749              \$obj$index  = new \$cls();
 750              \$obj".$index."->hydrate(\$rs, \$startcol$index);
 751              
 752              \$newObject = true;
 753              for (\$j=0, \$resCount=count(\$results); \$j < \$resCount; \$j++) {
 754                  \$temp_obj1 = \$results[\$j];
 755                  \$temp_obj$index = \$temp_obj1->get".$thisTableObjectBuilder->getFKPhpNameAffix($subfk, $plural=false)."(); //CHECKME
 756                  if (\$temp_obj".$index."->getPrimaryKey() === \$obj".$index."->getPrimaryKey()) {
 757                      \$newObject = false;
 758                      \$temp_obj".$index."->add".$joinedTableObjectBuilder->getRefFKPhpNameAffix($subfk, $plural=false)."(\$obj1);
 759                      break;
 760                  }
 761              }
 762              
 763              if (\$newObject) {
 764                  \$obj".$index."->init".$joinedTableObjectBuilder->getRefFKPhpNameAffix($subfk, $plural=true)."();
 765                  \$obj".$index."->add".$joinedTableObjectBuilder->getRefFKPhpNameAffix($subfk, $plural=false)."(\$obj1);
 766              }
 767  ";
 768                      } // if ($joinClassName != $excludedClassName) {
 769              } // $subfk->getForeignTableName() != $table->getName()
 770          } // foreach  
 771          $script .= "
 772              \$results[] = \$obj1;
 773          }
 774          return \$results;
 775      }
 776  ";
 777          } // foreach fk
 778  
 779      } // addDoSelectJoinAllExcept
 780      
 781      /**
 782       * Adds the doCountJoinAllExcept*() methods.
 783       * @param string &$script The script will be modified in this method.
 784       */
 785  	protected function addDoCountJoinAllExcept(&$script)
 786      {
 787          $table = $this->getTable();
 788          
 789          $fkeys = $table->getForeignKeys();  // this sep assignment is necessary otherwise sub-loops over 
 790                                              // getForeignKeys() will cause this to only execute one time.
 791          foreach ($fkeys as $fk ) {
 792  
 793              $tblFK = $table->getDatabase()->getTable($fk->getForeignTableName());
 794  
 795              $excludedTable = $table->getDatabase()->getTable($fk->getForeignTableName());
 796              $excludedClassName = $excludedTable->getPhpName();
 797  
 798              $thisTableObjectBuilder = OMBuilder::getNewObjectBuilder($table);
 799              $excludedTableObjectBuilder = OMBuilder::getNewObjectBuilder($excludedTable);
 800              $excludedTablePeerBuilder = OMBuilder::getNewPeerBuilder($excludedTable);
 801                  
 802          $script .= "
 803  
 804      /**
 805       * Returns the number of rows matching criteria, joining the related ".$thisTableObjectBuilder->getFKPhpNameAffix($fk, $plural = false)." table
 806       *
 807       * @param Criteria \$c
 808       * @param boolean \$distinct Whether to select only distinct columns (You can also set DISTINCT modifier in Criteria).
 809       * @param Connection \$con
 810       * @return int Number of matching rows.
 811       */
 812  	public static function doCountJoinAllExcept".$thisTableObjectBuilder->getFKPhpNameAffix($fk, $plural = false)."(Criteria \$criteria, \$distinct = false, \$con = null)
 813      {
 814          // we're going to modify criteria, so copy it first
 815          \$criteria = clone \$criteria;
 816          
 817          // clear out anything that might confuse the ORDER BY clause
 818          \$criteria->clearSelectColumns()->clearOrderByColumns();
 819          if (\$distinct || in_array(Criteria::DISTINCT, \$criteria->getSelectModifiers())) {
 820              \$criteria->addSelectColumn(".$this->getPeerClassname()."::COUNT_DISTINCT);
 821          } else {
 822              \$criteria->addSelectColumn(".$this->getPeerClassname()."::COUNT);
 823          }
 824          
 825          // just in case we're grouping: add those columns to the select statement
 826          foreach(\$criteria->getGroupByColumns() as \$column)
 827          {
 828              \$criteria->addSelectColumn(\$column);
 829          }
 830  ";    
 831  
 832              foreach ($table->getForeignKeys() as $subfk) {
 833                  // want to cover this case, but the code is not there yet.
 834                  if ( $subfk->getForeignTableName() != $table->getName() ) {
 835                      $joinTable = $table->getDatabase()->getTable($subfk->getForeignTableName());
 836                      $joinClassName = $joinTable->getPhpName();
 837                      $joinTablePeerBuilder = OMBuilder::getNewPeerBuilder($joinTable);
 838  
 839                      if($joinClassName != $excludedClassName)
 840                      {
 841                          $lfMap = $subfk->getLocalForeignMapping();
 842                          foreach ($subfk->getLocalColumns() as $columnName ) {
 843                              $column = $table->getColumn($columnName);
 844                              $columnFk = $joinTable->getColumn( $lfMap[$columnName]);
 845                              $script .= "
 846          \$criteria->addJoin(".$this->getColumnConstant($column).", ".$joinTablePeerBuilder->getColumnConstant($columnFk).");
 847  ";
 848                          }
 849                      } 
 850                  }
 851              } // foreach fkeys 
 852              $script .= "
 853          \$rs = ".$this->getPeerClassname()."::doSelectRS(\$criteria, \$con);
 854          if (\$rs->next()) {
 855              return \$rs->getInt(1);
 856          } else {
 857              // no rows returned; we infer that means 0 matches.
 858              return 0;
 859          }
 860      }
 861  ";
 862          } // foreach fk
 863  
 864      } // addDoCountJoinAllExcept
 865      
 866  } // PHP5ComplexPeerBuilder