1: <?php
   2: 
   3: namespace Thelia\Model\om;
   4: 
   5: use \BasePeer;
   6: use \Criteria;
   7: use \PDO;
   8: use \PDOStatement;
   9: use \Propel;
  10: use \PropelException;
  11: use \PropelPDO;
  12: use Thelia\Model\CategoryPeer;
  13: use Thelia\Model\ContentPeer;
  14: use Thelia\Model\FolderPeer;
  15: use Thelia\Model\ProductPeer;
  16: use Thelia\Model\Rewriting;
  17: use Thelia\Model\RewritingPeer;
  18: use Thelia\Model\map\RewritingTableMap;
  19: 
  20: /**
  21:  * Base static class for performing query and update operations on the 'rewriting' table.
  22:  *
  23:  *
  24:  *
  25:  * @package propel.generator.Thelia.Model.om
  26:  */
  27: abstract class BaseRewritingPeer
  28: {
  29: 
  30:     /** the default database name for this class */
  31:     const DATABASE_NAME = 'thelia';
  32: 
  33:     /** the table name for this class */
  34:     const TABLE_NAME = 'rewriting';
  35: 
  36:     /** the related Propel class for this table */
  37:     const OM_CLASS = 'Thelia\\Model\\Rewriting';
  38: 
  39:     /** the related TableMap class for this table */
  40:     const TM_CLASS = 'RewritingTableMap';
  41: 
  42:     /** The total number of columns. */
  43:     const NUM_COLUMNS = 8;
  44: 
  45:     /** The number of lazy-loaded columns. */
  46:     const NUM_LAZY_LOAD_COLUMNS = 0;
  47: 
  48:     /** The number of columns to hydrate (NUM_COLUMNS - NUM_LAZY_LOAD_COLUMNS) */
  49:     const NUM_HYDRATE_COLUMNS = 8;
  50: 
  51:     /** the column name for the ID field */
  52:     const ID = 'rewriting.ID';
  53: 
  54:     /** the column name for the URL field */
  55:     const URL = 'rewriting.URL';
  56: 
  57:     /** the column name for the PRODUCT_ID field */
  58:     const PRODUCT_ID = 'rewriting.PRODUCT_ID';
  59: 
  60:     /** the column name for the CATEGORY_ID field */
  61:     const CATEGORY_ID = 'rewriting.CATEGORY_ID';
  62: 
  63:     /** the column name for the FOLDER_ID field */
  64:     const FOLDER_ID = 'rewriting.FOLDER_ID';
  65: 
  66:     /** the column name for the CONTENT_ID field */
  67:     const CONTENT_ID = 'rewriting.CONTENT_ID';
  68: 
  69:     /** the column name for the CREATED_AT field */
  70:     const CREATED_AT = 'rewriting.CREATED_AT';
  71: 
  72:     /** the column name for the UPDATED_AT field */
  73:     const UPDATED_AT = 'rewriting.UPDATED_AT';
  74: 
  75:     /** The default string format for model objects of the related table **/
  76:     const DEFAULT_STRING_FORMAT = 'YAML';
  77: 
  78:     /**
  79:      * An identiy map to hold any loaded instances of Rewriting objects.
  80:      * This must be public so that other peer classes can access this when hydrating from JOIN
  81:      * queries.
  82:      * @var        array Rewriting[]
  83:      */
  84:     public static $instances = array();
  85: 
  86: 
  87:     /**
  88:      * holds an array of fieldnames
  89:      *
  90:      * first dimension keys are the type constants
  91:      * e.g. RewritingPeer::$fieldNames[RewritingPeer::TYPE_PHPNAME][0] = 'Id'
  92:      */
  93:     protected static $fieldNames = array (
  94:         BasePeer::TYPE_PHPNAME => array ('Id', 'Url', 'ProductId', 'CategoryId', 'FolderId', 'ContentId', 'CreatedAt', 'UpdatedAt', ),
  95:         BasePeer::TYPE_STUDLYPHPNAME => array ('id', 'url', 'productId', 'categoryId', 'folderId', 'contentId', 'createdAt', 'updatedAt', ),
  96:         BasePeer::TYPE_COLNAME => array (RewritingPeer::ID, RewritingPeer::URL, RewritingPeer::PRODUCT_ID, RewritingPeer::CATEGORY_ID, RewritingPeer::FOLDER_ID, RewritingPeer::CONTENT_ID, RewritingPeer::CREATED_AT, RewritingPeer::UPDATED_AT, ),
  97:         BasePeer::TYPE_RAW_COLNAME => array ('ID', 'URL', 'PRODUCT_ID', 'CATEGORY_ID', 'FOLDER_ID', 'CONTENT_ID', 'CREATED_AT', 'UPDATED_AT', ),
  98:         BasePeer::TYPE_FIELDNAME => array ('id', 'url', 'product_id', 'category_id', 'folder_id', 'content_id', 'created_at', 'updated_at', ),
  99:         BasePeer::TYPE_NUM => array (0, 1, 2, 3, 4, 5, 6, 7, )
 100:     );
 101: 
 102:     /**
 103:      * holds an array of keys for quick access to the fieldnames array
 104:      *
 105:      * first dimension keys are the type constants
 106:      * e.g. RewritingPeer::$fieldNames[BasePeer::TYPE_PHPNAME]['Id'] = 0
 107:      */
 108:     protected static $fieldKeys = array (
 109:         BasePeer::TYPE_PHPNAME => array ('Id' => 0, 'Url' => 1, 'ProductId' => 2, 'CategoryId' => 3, 'FolderId' => 4, 'ContentId' => 5, 'CreatedAt' => 6, 'UpdatedAt' => 7, ),
 110:         BasePeer::TYPE_STUDLYPHPNAME => array ('id' => 0, 'url' => 1, 'productId' => 2, 'categoryId' => 3, 'folderId' => 4, 'contentId' => 5, 'createdAt' => 6, 'updatedAt' => 7, ),
 111:         BasePeer::TYPE_COLNAME => array (RewritingPeer::ID => 0, RewritingPeer::URL => 1, RewritingPeer::PRODUCT_ID => 2, RewritingPeer::CATEGORY_ID => 3, RewritingPeer::FOLDER_ID => 4, RewritingPeer::CONTENT_ID => 5, RewritingPeer::CREATED_AT => 6, RewritingPeer::UPDATED_AT => 7, ),
 112:         BasePeer::TYPE_RAW_COLNAME => array ('ID' => 0, 'URL' => 1, 'PRODUCT_ID' => 2, 'CATEGORY_ID' => 3, 'FOLDER_ID' => 4, 'CONTENT_ID' => 5, 'CREATED_AT' => 6, 'UPDATED_AT' => 7, ),
 113:         BasePeer::TYPE_FIELDNAME => array ('id' => 0, 'url' => 1, 'product_id' => 2, 'category_id' => 3, 'folder_id' => 4, 'content_id' => 5, 'created_at' => 6, 'updated_at' => 7, ),
 114:         BasePeer::TYPE_NUM => array (0, 1, 2, 3, 4, 5, 6, 7, )
 115:     );
 116: 
 117:     /**
 118:      * Translates a fieldname to another type
 119:      *
 120:      * @param      string $name field name
 121:      * @param      string $fromType One of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME
 122:      *                         BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM
 123:      * @param      string $toType   One of the class type constants
 124:      * @return string          translated name of the field.
 125:      * @throws PropelException - if the specified name could not be found in the fieldname mappings.
 126:      */
 127:     public static function translateFieldName($name, $fromType, $toType)
 128:     {
 129:         $toNames = RewritingPeer::getFieldNames($toType);
 130:         $key = isset(RewritingPeer::$fieldKeys[$fromType][$name]) ? RewritingPeer::$fieldKeys[$fromType][$name] : null;
 131:         if ($key === null) {
 132:             throw new PropelException("'$name' could not be found in the field names of type '$fromType'. These are: " . print_r(RewritingPeer::$fieldKeys[$fromType], true));
 133:         }
 134: 
 135:         return $toNames[$key];
 136:     }
 137: 
 138:     /**
 139:      * Returns an array of field names.
 140:      *
 141:      * @param      string $type The type of fieldnames to return:
 142:      *                      One of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME
 143:      *                      BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM
 144:      * @return array           A list of field names
 145:      * @throws PropelException - if the type is not valid.
 146:      */
 147:     public static function getFieldNames($type = BasePeer::TYPE_PHPNAME)
 148:     {
 149:         if (!array_key_exists($type, RewritingPeer::$fieldNames)) {
 150:             throw new PropelException('Method getFieldNames() expects the parameter $type to be one of the class constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME, BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM. ' . $type . ' was given.');
 151:         }
 152: 
 153:         return RewritingPeer::$fieldNames[$type];
 154:     }
 155: 
 156:     /**
 157:      * Convenience method which changes table.column to alias.column.
 158:      *
 159:      * Using this method you can maintain SQL abstraction while using column aliases.
 160:      * <code>
 161:      *      $c->addAlias("alias1", TablePeer::TABLE_NAME);
 162:      *      $c->addJoin(TablePeer::alias("alias1", TablePeer::PRIMARY_KEY_COLUMN), TablePeer::PRIMARY_KEY_COLUMN);
 163:      * </code>
 164:      * @param      string $alias The alias for the current table.
 165:      * @param      string $column The column name for current table. (i.e. RewritingPeer::COLUMN_NAME).
 166:      * @return string
 167:      */
 168:     public static function alias($alias, $column)
 169:     {
 170:         return str_replace(RewritingPeer::TABLE_NAME.'.', $alias.'.', $column);
 171:     }
 172: 
 173:     /**
 174:      * Add all the columns needed to create a new object.
 175:      *
 176:      * Note: any columns that were marked with lazyLoad="true" in the
 177:      * XML schema will not be added to the select list and only loaded
 178:      * on demand.
 179:      *
 180:      * @param      Criteria $criteria object containing the columns to add.
 181:      * @param      string   $alias    optional table alias
 182:      * @throws PropelException Any exceptions caught during processing will be
 183:      *       rethrown wrapped into a PropelException.
 184:      */
 185:     public static function addSelectColumns(Criteria $criteria, $alias = null)
 186:     {
 187:         if (null === $alias) {
 188:             $criteria->addSelectColumn(RewritingPeer::ID);
 189:             $criteria->addSelectColumn(RewritingPeer::URL);
 190:             $criteria->addSelectColumn(RewritingPeer::PRODUCT_ID);
 191:             $criteria->addSelectColumn(RewritingPeer::CATEGORY_ID);
 192:             $criteria->addSelectColumn(RewritingPeer::FOLDER_ID);
 193:             $criteria->addSelectColumn(RewritingPeer::CONTENT_ID);
 194:             $criteria->addSelectColumn(RewritingPeer::CREATED_AT);
 195:             $criteria->addSelectColumn(RewritingPeer::UPDATED_AT);
 196:         } else {
 197:             $criteria->addSelectColumn($alias . '.ID');
 198:             $criteria->addSelectColumn($alias . '.URL');
 199:             $criteria->addSelectColumn($alias . '.PRODUCT_ID');
 200:             $criteria->addSelectColumn($alias . '.CATEGORY_ID');
 201:             $criteria->addSelectColumn($alias . '.FOLDER_ID');
 202:             $criteria->addSelectColumn($alias . '.CONTENT_ID');
 203:             $criteria->addSelectColumn($alias . '.CREATED_AT');
 204:             $criteria->addSelectColumn($alias . '.UPDATED_AT');
 205:         }
 206:     }
 207: 
 208:     /**
 209:      * Returns the number of rows matching criteria.
 210:      *
 211:      * @param      Criteria $criteria
 212:      * @param      boolean $distinct Whether to select only distinct columns; deprecated: use Criteria->setDistinct() instead.
 213:      * @param      PropelPDO $con
 214:      * @return int Number of matching rows.
 215:      */
 216:     public static function doCount(Criteria $criteria, $distinct = false, PropelPDO $con = null)
 217:     {
 218:         // we may modify criteria, so copy it first
 219:         $criteria = clone $criteria;
 220: 
 221:         // We need to set the primary table name, since in the case that there are no WHERE columns
 222:         // it will be impossible for the BasePeer::createSelectSql() method to determine which
 223:         // tables go into the FROM clause.
 224:         $criteria->setPrimaryTableName(RewritingPeer::TABLE_NAME);
 225: 
 226:         if ($distinct && !in_array(Criteria::DISTINCT, $criteria->getSelectModifiers())) {
 227:             $criteria->setDistinct();
 228:         }
 229: 
 230:         if (!$criteria->hasSelectClause()) {
 231:             RewritingPeer::addSelectColumns($criteria);
 232:         }
 233: 
 234:         $criteria->clearOrderByColumns(); // ORDER BY won't ever affect the count
 235:         $criteria->setDbName(RewritingPeer::DATABASE_NAME); // Set the correct dbName
 236: 
 237:         if ($con === null) {
 238:             $con = Propel::getConnection(RewritingPeer::DATABASE_NAME, Propel::CONNECTION_READ);
 239:         }
 240:         // BasePeer returns a PDOStatement
 241:         $stmt = BasePeer::doCount($criteria, $con);
 242: 
 243:         if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
 244:             $count = (int) $row[0];
 245:         } else {
 246:             $count = 0; // no rows returned; we infer that means 0 matches.
 247:         }
 248:         $stmt->closeCursor();
 249: 
 250:         return $count;
 251:     }
 252:     /**
 253:      * Selects one object from the DB.
 254:      *
 255:      * @param      Criteria $criteria object used to create the SELECT statement.
 256:      * @param      PropelPDO $con
 257:      * @return                 Rewriting
 258:      * @throws PropelException Any exceptions caught during processing will be
 259:      *       rethrown wrapped into a PropelException.
 260:      */
 261:     public static function doSelectOne(Criteria $criteria, PropelPDO $con = null)
 262:     {
 263:         $critcopy = clone $criteria;
 264:         $critcopy->setLimit(1);
 265:         $objects = RewritingPeer::doSelect($critcopy, $con);
 266:         if ($objects) {
 267:             return $objects[0];
 268:         }
 269: 
 270:         return null;
 271:     }
 272:     /**
 273:      * Selects several row from the DB.
 274:      *
 275:      * @param      Criteria $criteria The Criteria object used to build the SELECT statement.
 276:      * @param      PropelPDO $con
 277:      * @return array           Array of selected Objects
 278:      * @throws PropelException Any exceptions caught during processing will be
 279:      *       rethrown wrapped into a PropelException.
 280:      */
 281:     public static function doSelect(Criteria $criteria, PropelPDO $con = null)
 282:     {
 283:         return RewritingPeer::populateObjects(RewritingPeer::doSelectStmt($criteria, $con));
 284:     }
 285:     /**
 286:      * Prepares the Criteria object and uses the parent doSelect() method to execute a PDOStatement.
 287:      *
 288:      * Use this method directly if you want to work with an executed statement durirectly (for example
 289:      * to perform your own object hydration).
 290:      *
 291:      * @param      Criteria $criteria The Criteria object used to build the SELECT statement.
 292:      * @param      PropelPDO $con The connection to use
 293:      * @throws PropelException Any exceptions caught during processing will be
 294:      *       rethrown wrapped into a PropelException.
 295:      * @return PDOStatement The executed PDOStatement object.
 296:      * @see        BasePeer::doSelect()
 297:      */
 298:     public static function doSelectStmt(Criteria $criteria, PropelPDO $con = null)
 299:     {
 300:         if ($con === null) {
 301:             $con = Propel::getConnection(RewritingPeer::DATABASE_NAME, Propel::CONNECTION_READ);
 302:         }
 303: 
 304:         if (!$criteria->hasSelectClause()) {
 305:             $criteria = clone $criteria;
 306:             RewritingPeer::addSelectColumns($criteria);
 307:         }
 308: 
 309:         // Set the correct dbName
 310:         $criteria->setDbName(RewritingPeer::DATABASE_NAME);
 311: 
 312:         // BasePeer returns a PDOStatement
 313:         return BasePeer::doSelect($criteria, $con);
 314:     }
 315:     /**
 316:      * Adds an object to the instance pool.
 317:      *
 318:      * Propel keeps cached copies of objects in an instance pool when they are retrieved
 319:      * from the database.  In some cases -- especially when you override doSelect*()
 320:      * methods in your stub classes -- you may need to explicitly add objects
 321:      * to the cache in order to ensure that the same objects are always returned by doSelect*()
 322:      * and retrieveByPK*() calls.
 323:      *
 324:      * @param      Rewriting $obj A Rewriting object.
 325:      * @param      string $key (optional) key to use for instance map (for performance boost if key was already calculated externally).
 326:      */
 327:     public static function addInstanceToPool($obj, $key = null)
 328:     {
 329:         if (Propel::isInstancePoolingEnabled()) {
 330:             if ($key === null) {
 331:                 $key = (string) $obj->getId();
 332:             } // if key === null
 333:             RewritingPeer::$instances[$key] = $obj;
 334:         }
 335:     }
 336: 
 337:     /**
 338:      * Removes an object from the instance pool.
 339:      *
 340:      * Propel keeps cached copies of objects in an instance pool when they are retrieved
 341:      * from the database.  In some cases -- especially when you override doDelete
 342:      * methods in your stub classes -- you may need to explicitly remove objects
 343:      * from the cache in order to prevent returning objects that no longer exist.
 344:      *
 345:      * @param      mixed $value A Rewriting object or a primary key value.
 346:      *
 347:      * @return void
 348:      * @throws PropelException - if the value is invalid.
 349:      */
 350:     public static function removeInstanceFromPool($value)
 351:     {
 352:         if (Propel::isInstancePoolingEnabled() && $value !== null) {
 353:             if (is_object($value) && $value instanceof Rewriting) {
 354:                 $key = (string) $value->getId();
 355:             } elseif (is_scalar($value)) {
 356:                 // assume we've been passed a primary key
 357:                 $key = (string) $value;
 358:             } else {
 359:                 $e = new PropelException("Invalid value passed to removeInstanceFromPool().  Expected primary key or Rewriting object; got " . (is_object($value) ? get_class($value) . ' object.' : var_export($value,true)));
 360:                 throw $e;
 361:             }
 362: 
 363:             unset(RewritingPeer::$instances[$key]);
 364:         }
 365:     } // removeInstanceFromPool()
 366: 
 367:     /**
 368:      * Retrieves a string version of the primary key from the DB resultset row that can be used to uniquely identify a row in this table.
 369:      *
 370:      * For tables with a single-column primary key, that simple pkey value will be returned.  For tables with
 371:      * a multi-column primary key, a serialize()d version of the primary key will be returned.
 372:      *
 373:      * @param      string $key The key (@see getPrimaryKeyHash()) for this instance.
 374:      * @return   Rewriting Found object or null if 1) no instance exists for specified key or 2) instance pooling has been disabled.
 375:      * @see        getPrimaryKeyHash()
 376:      */
 377:     public static function getInstanceFromPool($key)
 378:     {
 379:         if (Propel::isInstancePoolingEnabled()) {
 380:             if (isset(RewritingPeer::$instances[$key])) {
 381:                 return RewritingPeer::$instances[$key];
 382:             }
 383:         }
 384: 
 385:         return null; // just to be explicit
 386:     }
 387: 
 388:     /**
 389:      * Clear the instance pool.
 390:      *
 391:      * @return void
 392:      */
 393:     public static function clearInstancePool()
 394:     {
 395:         RewritingPeer::$instances = array();
 396:     }
 397: 
 398:     /**
 399:      * Method to invalidate the instance pool of all tables related to rewriting
 400:      * by a foreign key with ON DELETE CASCADE
 401:      */
 402:     public static function clearRelatedInstancePool()
 403:     {
 404:     }
 405: 
 406:     /**
 407:      * Retrieves a string version of the primary key from the DB resultset row that can be used to uniquely identify a row in this table.
 408:      *
 409:      * For tables with a single-column primary key, that simple pkey value will be returned.  For tables with
 410:      * a multi-column primary key, a serialize()d version of the primary key will be returned.
 411:      *
 412:      * @param      array $row PropelPDO resultset row.
 413:      * @param      int $startcol The 0-based offset for reading from the resultset row.
 414:      * @return string A string version of PK or null if the components of primary key in result array are all null.
 415:      */
 416:     public static function getPrimaryKeyHashFromRow($row, $startcol = 0)
 417:     {
 418:         // If the PK cannot be derived from the row, return null.
 419:         if ($row[$startcol] === null) {
 420:             return null;
 421:         }
 422: 
 423:         return (string) $row[$startcol];
 424:     }
 425: 
 426:     /**
 427:      * Retrieves the primary key from the DB resultset row
 428:      * For tables with a single-column primary key, that simple pkey value will be returned.  For tables with
 429:      * a multi-column primary key, an array of the primary key columns will be returned.
 430:      *
 431:      * @param      array $row PropelPDO resultset row.
 432:      * @param      int $startcol The 0-based offset for reading from the resultset row.
 433:      * @return mixed The primary key of the row
 434:      */
 435:     public static function getPrimaryKeyFromRow($row, $startcol = 0)
 436:     {
 437: 
 438:         return (int) $row[$startcol];
 439:     }
 440: 
 441:     /**
 442:      * The returned array will contain objects of the default type or
 443:      * objects that inherit from the default.
 444:      *
 445:      * @throws PropelException Any exceptions caught during processing will be
 446:      *       rethrown wrapped into a PropelException.
 447:      */
 448:     public static function populateObjects(PDOStatement $stmt)
 449:     {
 450:         $results = array();
 451: 
 452:         // set the class once to avoid overhead in the loop
 453:         $cls = RewritingPeer::getOMClass();
 454:         // populate the object(s)
 455:         while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
 456:             $key = RewritingPeer::getPrimaryKeyHashFromRow($row, 0);
 457:             if (null !== ($obj = RewritingPeer::getInstanceFromPool($key))) {
 458:                 // We no longer rehydrate the object, since this can cause data loss.
 459:                 // See http://www.propelorm.org/ticket/509
 460:                 // $obj->hydrate($row, 0, true); // rehydrate
 461:                 $results[] = $obj;
 462:             } else {
 463:                 $obj = new $cls();
 464:                 $obj->hydrate($row);
 465:                 $results[] = $obj;
 466:                 RewritingPeer::addInstanceToPool($obj, $key);
 467:             } // if key exists
 468:         }
 469:         $stmt->closeCursor();
 470: 
 471:         return $results;
 472:     }
 473:     /**
 474:      * Populates an object of the default type or an object that inherit from the default.
 475:      *
 476:      * @param      array $row PropelPDO resultset row.
 477:      * @param      int $startcol The 0-based offset for reading from the resultset row.
 478:      * @throws PropelException Any exceptions caught during processing will be
 479:      *       rethrown wrapped into a PropelException.
 480:      * @return array (Rewriting object, last column rank)
 481:      */
 482:     public static function populateObject($row, $startcol = 0)
 483:     {
 484:         $key = RewritingPeer::getPrimaryKeyHashFromRow($row, $startcol);
 485:         if (null !== ($obj = RewritingPeer::getInstanceFromPool($key))) {
 486:             // We no longer rehydrate the object, since this can cause data loss.
 487:             // See http://www.propelorm.org/ticket/509
 488:             // $obj->hydrate($row, $startcol, true); // rehydrate
 489:             $col = $startcol + RewritingPeer::NUM_HYDRATE_COLUMNS;
 490:         } else {
 491:             $cls = RewritingPeer::OM_CLASS;
 492:             $obj = new $cls();
 493:             $col = $obj->hydrate($row, $startcol);
 494:             RewritingPeer::addInstanceToPool($obj, $key);
 495:         }
 496: 
 497:         return array($obj, $col);
 498:     }
 499: 
 500: 
 501:     /**
 502:      * Returns the number of rows matching criteria, joining the related Product table
 503:      *
 504:      * @param      Criteria $criteria
 505:      * @param      boolean $distinct Whether to select only distinct columns; deprecated: use Criteria->setDistinct() instead.
 506:      * @param      PropelPDO $con
 507:      * @param      String    $join_behavior the type of joins to use, defaults to Criteria::LEFT_JOIN
 508:      * @return int Number of matching rows.
 509:      */
 510:     public static function doCountJoinProduct(Criteria $criteria, $distinct = false, PropelPDO $con = null, $join_behavior = Criteria::LEFT_JOIN)
 511:     {
 512:         // we're going to modify criteria, so copy it first
 513:         $criteria = clone $criteria;
 514: 
 515:         // We need to set the primary table name, since in the case that there are no WHERE columns
 516:         // it will be impossible for the BasePeer::createSelectSql() method to determine which
 517:         // tables go into the FROM clause.
 518:         $criteria->setPrimaryTableName(RewritingPeer::TABLE_NAME);
 519: 
 520:         if ($distinct && !in_array(Criteria::DISTINCT, $criteria->getSelectModifiers())) {
 521:             $criteria->setDistinct();
 522:         }
 523: 
 524:         if (!$criteria->hasSelectClause()) {
 525:             RewritingPeer::addSelectColumns($criteria);
 526:         }
 527: 
 528:         $criteria->clearOrderByColumns(); // ORDER BY won't ever affect the count
 529: 
 530:         // Set the correct dbName
 531:         $criteria->setDbName(RewritingPeer::DATABASE_NAME);
 532: 
 533:         if ($con === null) {
 534:             $con = Propel::getConnection(RewritingPeer::DATABASE_NAME, Propel::CONNECTION_READ);
 535:         }
 536: 
 537:         $criteria->addJoin(RewritingPeer::PRODUCT_ID, ProductPeer::ID, $join_behavior);
 538: 
 539:         $stmt = BasePeer::doCount($criteria, $con);
 540: 
 541:         if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
 542:             $count = (int) $row[0];
 543:         } else {
 544:             $count = 0; // no rows returned; we infer that means 0 matches.
 545:         }
 546:         $stmt->closeCursor();
 547: 
 548:         return $count;
 549:     }
 550: 
 551: 
 552:     /**
 553:      * Returns the number of rows matching criteria, joining the related Category table
 554:      *
 555:      * @param      Criteria $criteria
 556:      * @param      boolean $distinct Whether to select only distinct columns; deprecated: use Criteria->setDistinct() instead.
 557:      * @param      PropelPDO $con
 558:      * @param      String    $join_behavior the type of joins to use, defaults to Criteria::LEFT_JOIN
 559:      * @return int Number of matching rows.
 560:      */
 561:     public static function doCountJoinCategory(Criteria $criteria, $distinct = false, PropelPDO $con = null, $join_behavior = Criteria::LEFT_JOIN)
 562:     {
 563:         // we're going to modify criteria, so copy it first
 564:         $criteria = clone $criteria;
 565: 
 566:         // We need to set the primary table name, since in the case that there are no WHERE columns
 567:         // it will be impossible for the BasePeer::createSelectSql() method to determine which
 568:         // tables go into the FROM clause.
 569:         $criteria->setPrimaryTableName(RewritingPeer::TABLE_NAME);
 570: 
 571:         if ($distinct && !in_array(Criteria::DISTINCT, $criteria->getSelectModifiers())) {
 572:             $criteria->setDistinct();
 573:         }
 574: 
 575:         if (!$criteria->hasSelectClause()) {
 576:             RewritingPeer::addSelectColumns($criteria);
 577:         }
 578: 
 579:         $criteria->clearOrderByColumns(); // ORDER BY won't ever affect the count
 580: 
 581:         // Set the correct dbName
 582:         $criteria->setDbName(RewritingPeer::DATABASE_NAME);
 583: 
 584:         if ($con === null) {
 585:             $con = Propel::getConnection(RewritingPeer::DATABASE_NAME, Propel::CONNECTION_READ);
 586:         }
 587: 
 588:         $criteria->addJoin(RewritingPeer::CATEGORY_ID, CategoryPeer::ID, $join_behavior);
 589: 
 590:         $stmt = BasePeer::doCount($criteria, $con);
 591: 
 592:         if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
 593:             $count = (int) $row[0];
 594:         } else {
 595:             $count = 0; // no rows returned; we infer that means 0 matches.
 596:         }
 597:         $stmt->closeCursor();
 598: 
 599:         return $count;
 600:     }
 601: 
 602: 
 603:     /**
 604:      * Returns the number of rows matching criteria, joining the related Folder table
 605:      *
 606:      * @param      Criteria $criteria
 607:      * @param      boolean $distinct Whether to select only distinct columns; deprecated: use Criteria->setDistinct() instead.
 608:      * @param      PropelPDO $con
 609:      * @param      String    $join_behavior the type of joins to use, defaults to Criteria::LEFT_JOIN
 610:      * @return int Number of matching rows.
 611:      */
 612:     public static function doCountJoinFolder(Criteria $criteria, $distinct = false, PropelPDO $con = null, $join_behavior = Criteria::LEFT_JOIN)
 613:     {
 614:         // we're going to modify criteria, so copy it first
 615:         $criteria = clone $criteria;
 616: 
 617:         // We need to set the primary table name, since in the case that there are no WHERE columns
 618:         // it will be impossible for the BasePeer::createSelectSql() method to determine which
 619:         // tables go into the FROM clause.
 620:         $criteria->setPrimaryTableName(RewritingPeer::TABLE_NAME);
 621: 
 622:         if ($distinct && !in_array(Criteria::DISTINCT, $criteria->getSelectModifiers())) {
 623:             $criteria->setDistinct();
 624:         }
 625: 
 626:         if (!$criteria->hasSelectClause()) {
 627:             RewritingPeer::addSelectColumns($criteria);
 628:         }
 629: 
 630:         $criteria->clearOrderByColumns(); // ORDER BY won't ever affect the count
 631: 
 632:         // Set the correct dbName
 633:         $criteria->setDbName(RewritingPeer::DATABASE_NAME);
 634: 
 635:         if ($con === null) {
 636:             $con = Propel::getConnection(RewritingPeer::DATABASE_NAME, Propel::CONNECTION_READ);
 637:         }
 638: 
 639:         $criteria->addJoin(RewritingPeer::FOLDER_ID, FolderPeer::ID, $join_behavior);
 640: 
 641:         $stmt = BasePeer::doCount($criteria, $con);
 642: 
 643:         if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
 644:             $count = (int) $row[0];
 645:         } else {
 646:             $count = 0; // no rows returned; we infer that means 0 matches.
 647:         }
 648:         $stmt->closeCursor();
 649: 
 650:         return $count;
 651:     }
 652: 
 653: 
 654:     /**
 655:      * Returns the number of rows matching criteria, joining the related Content table
 656:      *
 657:      * @param      Criteria $criteria
 658:      * @param      boolean $distinct Whether to select only distinct columns; deprecated: use Criteria->setDistinct() instead.
 659:      * @param      PropelPDO $con
 660:      * @param      String    $join_behavior the type of joins to use, defaults to Criteria::LEFT_JOIN
 661:      * @return int Number of matching rows.
 662:      */
 663:     public static function doCountJoinContent(Criteria $criteria, $distinct = false, PropelPDO $con = null, $join_behavior = Criteria::LEFT_JOIN)
 664:     {
 665:         // we're going to modify criteria, so copy it first
 666:         $criteria = clone $criteria;
 667: 
 668:         // We need to set the primary table name, since in the case that there are no WHERE columns
 669:         // it will be impossible for the BasePeer::createSelectSql() method to determine which
 670:         // tables go into the FROM clause.
 671:         $criteria->setPrimaryTableName(RewritingPeer::TABLE_NAME);
 672: 
 673:         if ($distinct && !in_array(Criteria::DISTINCT, $criteria->getSelectModifiers())) {
 674:             $criteria->setDistinct();
 675:         }
 676: 
 677:         if (!$criteria->hasSelectClause()) {
 678:             RewritingPeer::addSelectColumns($criteria);
 679:         }
 680: 
 681:         $criteria->clearOrderByColumns(); // ORDER BY won't ever affect the count
 682: 
 683:         // Set the correct dbName
 684:         $criteria->setDbName(RewritingPeer::DATABASE_NAME);
 685: 
 686:         if ($con === null) {
 687:             $con = Propel::getConnection(RewritingPeer::DATABASE_NAME, Propel::CONNECTION_READ);
 688:         }
 689: 
 690:         $criteria->addJoin(RewritingPeer::CONTENT_ID, ContentPeer::ID, $join_behavior);
 691: 
 692:         $stmt = BasePeer::doCount($criteria, $con);
 693: 
 694:         if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
 695:             $count = (int) $row[0];
 696:         } else {
 697:             $count = 0; // no rows returned; we infer that means 0 matches.
 698:         }
 699:         $stmt->closeCursor();
 700: 
 701:         return $count;
 702:     }
 703: 
 704: 
 705:     /**
 706:      * Selects a collection of Rewriting objects pre-filled with their Product objects.
 707:      * @param      Criteria  $criteria
 708:      * @param      PropelPDO $con
 709:      * @param      String    $join_behavior the type of joins to use, defaults to Criteria::LEFT_JOIN
 710:      * @return array           Array of Rewriting objects.
 711:      * @throws PropelException Any exceptions caught during processing will be
 712:      *       rethrown wrapped into a PropelException.
 713:      */
 714:     public static function doSelectJoinProduct(Criteria $criteria, $con = null, $join_behavior = Criteria::LEFT_JOIN)
 715:     {
 716:         $criteria = clone $criteria;
 717: 
 718:         // Set the correct dbName if it has not been overridden
 719:         if ($criteria->getDbName() == Propel::getDefaultDB()) {
 720:             $criteria->setDbName(RewritingPeer::DATABASE_NAME);
 721:         }
 722: 
 723:         RewritingPeer::addSelectColumns($criteria);
 724:         $startcol = RewritingPeer::NUM_HYDRATE_COLUMNS;
 725:         ProductPeer::addSelectColumns($criteria);
 726: 
 727:         $criteria->addJoin(RewritingPeer::PRODUCT_ID, ProductPeer::ID, $join_behavior);
 728: 
 729:         $stmt = BasePeer::doSelect($criteria, $con);
 730:         $results = array();
 731: 
 732:         while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
 733:             $key1 = RewritingPeer::getPrimaryKeyHashFromRow($row, 0);
 734:             if (null !== ($obj1 = RewritingPeer::getInstanceFromPool($key1))) {
 735:                 // We no longer rehydrate the object, since this can cause data loss.
 736:                 // See http://www.propelorm.org/ticket/509
 737:                 // $obj1->hydrate($row, 0, true); // rehydrate
 738:             } else {
 739: 
 740:                 $cls = RewritingPeer::getOMClass();
 741: 
 742:                 $obj1 = new $cls();
 743:                 $obj1->hydrate($row);
 744:                 RewritingPeer::addInstanceToPool($obj1, $key1);
 745:             } // if $obj1 already loaded
 746: 
 747:             $key2 = ProductPeer::getPrimaryKeyHashFromRow($row, $startcol);
 748:             if ($key2 !== null) {
 749:                 $obj2 = ProductPeer::getInstanceFromPool($key2);
 750:                 if (!$obj2) {
 751: 
 752:                     $cls = ProductPeer::getOMClass();
 753: 
 754:                     $obj2 = new $cls();
 755:                     $obj2->hydrate($row, $startcol);
 756:                     ProductPeer::addInstanceToPool($obj2, $key2);
 757:                 } // if obj2 already loaded
 758: 
 759:                 // Add the $obj1 (Rewriting) to $obj2 (Product)
 760:                 $obj2->addRewriting($obj1);
 761: 
 762:             } // if joined row was not null
 763: 
 764:             $results[] = $obj1;
 765:         }
 766:         $stmt->closeCursor();
 767: 
 768:         return $results;
 769:     }
 770: 
 771: 
 772:     /**
 773:      * Selects a collection of Rewriting objects pre-filled with their Category objects.
 774:      * @param      Criteria  $criteria
 775:      * @param      PropelPDO $con
 776:      * @param      String    $join_behavior the type of joins to use, defaults to Criteria::LEFT_JOIN
 777:      * @return array           Array of Rewriting objects.
 778:      * @throws PropelException Any exceptions caught during processing will be
 779:      *       rethrown wrapped into a PropelException.
 780:      */
 781:     public static function doSelectJoinCategory(Criteria $criteria, $con = null, $join_behavior = Criteria::LEFT_JOIN)
 782:     {
 783:         $criteria = clone $criteria;
 784: 
 785:         // Set the correct dbName if it has not been overridden
 786:         if ($criteria->getDbName() == Propel::getDefaultDB()) {
 787:             $criteria->setDbName(RewritingPeer::DATABASE_NAME);
 788:         }
 789: 
 790:         RewritingPeer::addSelectColumns($criteria);
 791:         $startcol = RewritingPeer::NUM_HYDRATE_COLUMNS;
 792:         CategoryPeer::addSelectColumns($criteria);
 793: 
 794:         $criteria->addJoin(RewritingPeer::CATEGORY_ID, CategoryPeer::ID, $join_behavior);
 795: 
 796:         $stmt = BasePeer::doSelect($criteria, $con);
 797:         $results = array();
 798: 
 799:         while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
 800:             $key1 = RewritingPeer::getPrimaryKeyHashFromRow($row, 0);
 801:             if (null !== ($obj1 = RewritingPeer::getInstanceFromPool($key1))) {
 802:                 // We no longer rehydrate the object, since this can cause data loss.
 803:                 // See http://www.propelorm.org/ticket/509
 804:                 // $obj1->hydrate($row, 0, true); // rehydrate
 805:             } else {
 806: 
 807:                 $cls = RewritingPeer::getOMClass();
 808: 
 809:                 $obj1 = new $cls();
 810:                 $obj1->hydrate($row);
 811:                 RewritingPeer::addInstanceToPool($obj1, $key1);
 812:             } // if $obj1 already loaded
 813: 
 814:             $key2 = CategoryPeer::getPrimaryKeyHashFromRow($row, $startcol);
 815:             if ($key2 !== null) {
 816:                 $obj2 = CategoryPeer::getInstanceFromPool($key2);
 817:                 if (!$obj2) {
 818: 
 819:                     $cls = CategoryPeer::getOMClass();
 820: 
 821:                     $obj2 = new $cls();
 822:                     $obj2->hydrate($row, $startcol);
 823:                     CategoryPeer::addInstanceToPool($obj2, $key2);
 824:                 } // if obj2 already loaded
 825: 
 826:                 // Add the $obj1 (Rewriting) to $obj2 (Category)
 827:                 $obj2->addRewriting($obj1);
 828: 
 829:             } // if joined row was not null
 830: 
 831:             $results[] = $obj1;
 832:         }
 833:         $stmt->closeCursor();
 834: 
 835:         return $results;
 836:     }
 837: 
 838: 
 839:     /**
 840:      * Selects a collection of Rewriting objects pre-filled with their Folder objects.
 841:      * @param      Criteria  $criteria
 842:      * @param      PropelPDO $con
 843:      * @param      String    $join_behavior the type of joins to use, defaults to Criteria::LEFT_JOIN
 844:      * @return array           Array of Rewriting objects.
 845:      * @throws PropelException Any exceptions caught during processing will be
 846:      *       rethrown wrapped into a PropelException.
 847:      */
 848:     public static function doSelectJoinFolder(Criteria $criteria, $con = null, $join_behavior = Criteria::LEFT_JOIN)
 849:     {
 850:         $criteria = clone $criteria;
 851: 
 852:         // Set the correct dbName if it has not been overridden
 853:         if ($criteria->getDbName() == Propel::getDefaultDB()) {
 854:             $criteria->setDbName(RewritingPeer::DATABASE_NAME);
 855:         }
 856: 
 857:         RewritingPeer::addSelectColumns($criteria);
 858:         $startcol = RewritingPeer::NUM_HYDRATE_COLUMNS;
 859:         FolderPeer::addSelectColumns($criteria);
 860: 
 861:         $criteria->addJoin(RewritingPeer::FOLDER_ID, FolderPeer::ID, $join_behavior);
 862: 
 863:         $stmt = BasePeer::doSelect($criteria, $con);
 864:         $results = array();
 865: 
 866:         while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
 867:             $key1 = RewritingPeer::getPrimaryKeyHashFromRow($row, 0);
 868:             if (null !== ($obj1 = RewritingPeer::getInstanceFromPool($key1))) {
 869:                 // We no longer rehydrate the object, since this can cause data loss.
 870:                 // See http://www.propelorm.org/ticket/509
 871:                 // $obj1->hydrate($row, 0, true); // rehydrate
 872:             } else {
 873: 
 874:                 $cls = RewritingPeer::getOMClass();
 875: 
 876:                 $obj1 = new $cls();
 877:                 $obj1->hydrate($row);
 878:                 RewritingPeer::addInstanceToPool($obj1, $key1);
 879:             } // if $obj1 already loaded
 880: 
 881:             $key2 = FolderPeer::getPrimaryKeyHashFromRow($row, $startcol);
 882:             if ($key2 !== null) {
 883:                 $obj2 = FolderPeer::getInstanceFromPool($key2);
 884:                 if (!$obj2) {
 885: 
 886:                     $cls = FolderPeer::getOMClass();
 887: 
 888:                     $obj2 = new $cls();
 889:                     $obj2->hydrate($row, $startcol);
 890:                     FolderPeer::addInstanceToPool($obj2, $key2);
 891:                 } // if obj2 already loaded
 892: 
 893:                 // Add the $obj1 (Rewriting) to $obj2 (Folder)
 894:                 $obj2->addRewriting($obj1);
 895: 
 896:             } // if joined row was not null
 897: 
 898:             $results[] = $obj1;
 899:         }
 900:         $stmt->closeCursor();
 901: 
 902:         return $results;
 903:     }
 904: 
 905: 
 906:     /**
 907:      * Selects a collection of Rewriting objects pre-filled with their Content objects.
 908:      * @param      Criteria  $criteria
 909:      * @param      PropelPDO $con
 910:      * @param      String    $join_behavior the type of joins to use, defaults to Criteria::LEFT_JOIN
 911:      * @return array           Array of Rewriting objects.
 912:      * @throws PropelException Any exceptions caught during processing will be
 913:      *       rethrown wrapped into a PropelException.
 914:      */
 915:     public static function doSelectJoinContent(Criteria $criteria, $con = null, $join_behavior = Criteria::LEFT_JOIN)
 916:     {
 917:         $criteria = clone $criteria;
 918: 
 919:         // Set the correct dbName if it has not been overridden
 920:         if ($criteria->getDbName() == Propel::getDefaultDB()) {
 921:             $criteria->setDbName(RewritingPeer::DATABASE_NAME);
 922:         }
 923: 
 924:         RewritingPeer::addSelectColumns($criteria);
 925:         $startcol = RewritingPeer::NUM_HYDRATE_COLUMNS;
 926:         ContentPeer::addSelectColumns($criteria);
 927: 
 928:         $criteria->addJoin(RewritingPeer::CONTENT_ID, ContentPeer::ID, $join_behavior);
 929: 
 930:         $stmt = BasePeer::doSelect($criteria, $con);
 931:         $results = array();
 932: 
 933:         while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
 934:             $key1 = RewritingPeer::getPrimaryKeyHashFromRow($row, 0);
 935:             if (null !== ($obj1 = RewritingPeer::getInstanceFromPool($key1))) {
 936:                 // We no longer rehydrate the object, since this can cause data loss.
 937:                 // See http://www.propelorm.org/ticket/509
 938:                 // $obj1->hydrate($row, 0, true); // rehydrate
 939:             } else {
 940: 
 941:                 $cls = RewritingPeer::getOMClass();
 942: 
 943:                 $obj1 = new $cls();
 944:                 $obj1->hydrate($row);
 945:                 RewritingPeer::addInstanceToPool($obj1, $key1);
 946:             } // if $obj1 already loaded
 947: 
 948:             $key2 = ContentPeer::getPrimaryKeyHashFromRow($row, $startcol);
 949:             if ($key2 !== null) {
 950:                 $obj2 = ContentPeer::getInstanceFromPool($key2);
 951:                 if (!$obj2) {
 952: 
 953:                     $cls = ContentPeer::getOMClass();
 954: 
 955:                     $obj2 = new $cls();
 956:                     $obj2->hydrate($row, $startcol);
 957:                     ContentPeer::addInstanceToPool($obj2, $key2);
 958:                 } // if obj2 already loaded
 959: 
 960:                 // Add the $obj1 (Rewriting) to $obj2 (Content)
 961:                 $obj2->addRewriting($obj1);
 962: 
 963:             } // if joined row was not null
 964: 
 965:             $results[] = $obj1;
 966:         }
 967:         $stmt->closeCursor();
 968: 
 969:         return $results;
 970:     }
 971: 
 972: 
 973:     /**
 974:      * Returns the number of rows matching criteria, joining all related tables
 975:      *
 976:      * @param      Criteria $criteria
 977:      * @param      boolean $distinct Whether to select only distinct columns; deprecated: use Criteria->setDistinct() instead.
 978:      * @param      PropelPDO $con
 979:      * @param      String    $join_behavior the type of joins to use, defaults to Criteria::LEFT_JOIN
 980:      * @return int Number of matching rows.
 981:      */
 982:     public static function doCountJoinAll(Criteria $criteria, $distinct = false, PropelPDO $con = null, $join_behavior = Criteria::LEFT_JOIN)
 983:     {
 984:         // we're going to modify criteria, so copy it first
 985:         $criteria = clone $criteria;
 986: 
 987:         // We need to set the primary table name, since in the case that there are no WHERE columns
 988:         // it will be impossible for the BasePeer::createSelectSql() method to determine which
 989:         // tables go into the FROM clause.
 990:         $criteria->setPrimaryTableName(RewritingPeer::TABLE_NAME);
 991: 
 992:         if ($distinct && !in_array(Criteria::DISTINCT, $criteria->getSelectModifiers())) {
 993:             $criteria->setDistinct();
 994:         }
 995: 
 996:         if (!$criteria->hasSelectClause()) {
 997:             RewritingPeer::addSelectColumns($criteria);
 998:         }
 999: 
1000:         $criteria->clearOrderByColumns(); // ORDER BY won't ever affect the count
1001: 
1002:         // Set the correct dbName
1003:         $criteria->setDbName(RewritingPeer::DATABASE_NAME);
1004: 
1005:         if ($con === null) {
1006:             $con = Propel::getConnection(RewritingPeer::DATABASE_NAME, Propel::CONNECTION_READ);
1007:         }
1008: 
1009:         $criteria->addJoin(RewritingPeer::PRODUCT_ID, ProductPeer::ID, $join_behavior);
1010: 
1011:         $criteria->addJoin(RewritingPeer::CATEGORY_ID, CategoryPeer::ID, $join_behavior);
1012: 
1013:         $criteria->addJoin(RewritingPeer::FOLDER_ID, FolderPeer::ID, $join_behavior);
1014: 
1015:         $criteria->addJoin(RewritingPeer::CONTENT_ID, ContentPeer::ID, $join_behavior);
1016: 
1017:         $stmt = BasePeer::doCount($criteria, $con);
1018: 
1019:         if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
1020:             $count = (int) $row[0];
1021:         } else {
1022:             $count = 0; // no rows returned; we infer that means 0 matches.
1023:         }
1024:         $stmt->closeCursor();
1025: 
1026:         return $count;
1027:     }
1028: 
1029:     /**
1030:      * Selects a collection of Rewriting objects pre-filled with all related objects.
1031:      *
1032:      * @param      Criteria  $criteria
1033:      * @param      PropelPDO $con
1034:      * @param      String    $join_behavior the type of joins to use, defaults to Criteria::LEFT_JOIN
1035:      * @return array           Array of Rewriting objects.
1036:      * @throws PropelException Any exceptions caught during processing will be
1037:      *       rethrown wrapped into a PropelException.
1038:      */
1039:     public static function doSelectJoinAll(Criteria $criteria, $con = null, $join_behavior = Criteria::LEFT_JOIN)
1040:     {
1041:         $criteria = clone $criteria;
1042: 
1043:         // Set the correct dbName if it has not been overridden
1044:         if ($criteria->getDbName() == Propel::getDefaultDB()) {
1045:             $criteria->setDbName(RewritingPeer::DATABASE_NAME);
1046:         }
1047: 
1048:         RewritingPeer::addSelectColumns($criteria);
1049:         $startcol2 = RewritingPeer::NUM_HYDRATE_COLUMNS;
1050: 
1051:         ProductPeer::addSelectColumns($criteria);
1052:         $startcol3 = $startcol2 + ProductPeer::NUM_HYDRATE_COLUMNS;
1053: 
1054:         CategoryPeer::addSelectColumns($criteria);
1055:         $startcol4 = $startcol3 + CategoryPeer::NUM_HYDRATE_COLUMNS;
1056: 
1057:         FolderPeer::addSelectColumns($criteria);
1058:         $startcol5 = $startcol4 + FolderPeer::NUM_HYDRATE_COLUMNS;
1059: 
1060:         ContentPeer::addSelectColumns($criteria);
1061:         $startcol6 = $startcol5 + ContentPeer::NUM_HYDRATE_COLUMNS;
1062: 
1063:         $criteria->addJoin(RewritingPeer::PRODUCT_ID, ProductPeer::ID, $join_behavior);
1064: 
1065:         $criteria->addJoin(RewritingPeer::CATEGORY_ID, CategoryPeer::ID, $join_behavior);
1066: 
1067:         $criteria->addJoin(RewritingPeer::FOLDER_ID, FolderPeer::ID, $join_behavior);
1068: 
1069:         $criteria->addJoin(RewritingPeer::CONTENT_ID, ContentPeer::ID, $join_behavior);
1070: 
1071:         $stmt = BasePeer::doSelect($criteria, $con);
1072:         $results = array();
1073: 
1074:         while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
1075:             $key1 = RewritingPeer::getPrimaryKeyHashFromRow($row, 0);
1076:             if (null !== ($obj1 = RewritingPeer::getInstanceFromPool($key1))) {
1077:                 // We no longer rehydrate the object, since this can cause data loss.
1078:                 // See http://www.propelorm.org/ticket/509
1079:                 // $obj1->hydrate($row, 0, true); // rehydrate
1080:             } else {
1081:                 $cls = RewritingPeer::getOMClass();
1082: 
1083:                 $obj1 = new $cls();
1084:                 $obj1->hydrate($row);
1085:                 RewritingPeer::addInstanceToPool($obj1, $key1);
1086:             } // if obj1 already loaded
1087: 
1088:             // Add objects for joined Product rows
1089: 
1090:             $key2 = ProductPeer::getPrimaryKeyHashFromRow($row, $startcol2);
1091:             if ($key2 !== null) {
1092:                 $obj2 = ProductPeer::getInstanceFromPool($key2);
1093:                 if (!$obj2) {
1094: 
1095:                     $cls = ProductPeer::getOMClass();
1096: 
1097:                     $obj2 = new $cls();
1098:                     $obj2->hydrate($row, $startcol2);
1099:                     ProductPeer::addInstanceToPool($obj2, $key2);
1100:                 } // if obj2 loaded
1101: 
1102:                 // Add the $obj1 (Rewriting) to the collection in $obj2 (Product)
1103:                 $obj2->addRewriting($obj1);
1104:             } // if joined row not null
1105: 
1106:             // Add objects for joined Category rows
1107: 
1108:             $key3 = CategoryPeer::getPrimaryKeyHashFromRow($row, $startcol3);
1109:             if ($key3 !== null) {
1110:                 $obj3 = CategoryPeer::getInstanceFromPool($key3);
1111:                 if (!$obj3) {
1112: 
1113:                     $cls = CategoryPeer::getOMClass();
1114: 
1115:                     $obj3 = new $cls();
1116:                     $obj3->hydrate($row, $startcol3);
1117:                     CategoryPeer::addInstanceToPool($obj3, $key3);
1118:                 } // if obj3 loaded
1119: 
1120:                 // Add the $obj1 (Rewriting) to the collection in $obj3 (Category)
1121:                 $obj3->addRewriting($obj1);
1122:             } // if joined row not null
1123: 
1124:             // Add objects for joined Folder rows
1125: 
1126:             $key4 = FolderPeer::getPrimaryKeyHashFromRow($row, $startcol4);
1127:             if ($key4 !== null) {
1128:                 $obj4 = FolderPeer::getInstanceFromPool($key4);
1129:                 if (!$obj4) {
1130: 
1131:                     $cls = FolderPeer::getOMClass();
1132: 
1133:                     $obj4 = new $cls();
1134:                     $obj4->hydrate($row, $startcol4);
1135:                     FolderPeer::addInstanceToPool($obj4, $key4);
1136:                 } // if obj4 loaded
1137: 
1138:                 // Add the $obj1 (Rewriting) to the collection in $obj4 (Folder)
1139:                 $obj4->addRewriting($obj1);
1140:             } // if joined row not null
1141: 
1142:             // Add objects for joined Content rows
1143: 
1144:             $key5 = ContentPeer::getPrimaryKeyHashFromRow($row, $startcol5);
1145:             if ($key5 !== null) {
1146:                 $obj5 = ContentPeer::getInstanceFromPool($key5);
1147:                 if (!$obj5) {
1148: 
1149:                     $cls = ContentPeer::getOMClass();
1150: 
1151:                     $obj5 = new $cls();
1152:                     $obj5->hydrate($row, $startcol5);
1153:                     ContentPeer::addInstanceToPool($obj5, $key5);
1154:                 } // if obj5 loaded
1155: 
1156:                 // Add the $obj1 (Rewriting) to the collection in $obj5 (Content)
1157:                 $obj5->addRewriting($obj1);
1158:             } // if joined row not null
1159: 
1160:             $results[] = $obj1;
1161:         }
1162:         $stmt->closeCursor();
1163: 
1164:         return $results;
1165:     }
1166: 
1167: 
1168:     /**
1169:      * Returns the number of rows matching criteria, joining the related Product table
1170:      *
1171:      * @param      Criteria $criteria
1172:      * @param      boolean $distinct Whether to select only distinct columns; deprecated: use Criteria->setDistinct() instead.
1173:      * @param      PropelPDO $con
1174:      * @param      String    $join_behavior the type of joins to use, defaults to Criteria::LEFT_JOIN
1175:      * @return int Number of matching rows.
1176:      */
1177:     public static function doCountJoinAllExceptProduct(Criteria $criteria, $distinct = false, PropelPDO $con = null, $join_behavior = Criteria::LEFT_JOIN)
1178:     {
1179:         // we're going to modify criteria, so copy it first
1180:         $criteria = clone $criteria;
1181: 
1182:         // We need to set the primary table name, since in the case that there are no WHERE columns
1183:         // it will be impossible for the BasePeer::createSelectSql() method to determine which
1184:         // tables go into the FROM clause.
1185:         $criteria->setPrimaryTableName(RewritingPeer::TABLE_NAME);
1186: 
1187:         if ($distinct && !in_array(Criteria::DISTINCT, $criteria->getSelectModifiers())) {
1188:             $criteria->setDistinct();
1189:         }
1190: 
1191:         if (!$criteria->hasSelectClause()) {
1192:             RewritingPeer::addSelectColumns($criteria);
1193:         }
1194: 
1195:         $criteria->clearOrderByColumns(); // ORDER BY should not affect count
1196: 
1197:         // Set the correct dbName
1198:         $criteria->setDbName(RewritingPeer::DATABASE_NAME);
1199: 
1200:         if ($con === null) {
1201:             $con = Propel::getConnection(RewritingPeer::DATABASE_NAME, Propel::CONNECTION_READ);
1202:         }
1203: 
1204:         $criteria->addJoin(RewritingPeer::CATEGORY_ID, CategoryPeer::ID, $join_behavior);
1205: 
1206:         $criteria->addJoin(RewritingPeer::FOLDER_ID, FolderPeer::ID, $join_behavior);
1207: 
1208:         $criteria->addJoin(RewritingPeer::CONTENT_ID, ContentPeer::ID, $join_behavior);
1209: 
1210:         $stmt = BasePeer::doCount($criteria, $con);
1211: 
1212:         if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
1213:             $count = (int) $row[0];
1214:         } else {
1215:             $count = 0; // no rows returned; we infer that means 0 matches.
1216:         }
1217:         $stmt->closeCursor();
1218: 
1219:         return $count;
1220:     }
1221: 
1222: 
1223:     /**
1224:      * Returns the number of rows matching criteria, joining the related Category table
1225:      *
1226:      * @param      Criteria $criteria
1227:      * @param      boolean $distinct Whether to select only distinct columns; deprecated: use Criteria->setDistinct() instead.
1228:      * @param      PropelPDO $con
1229:      * @param      String    $join_behavior the type of joins to use, defaults to Criteria::LEFT_JOIN
1230:      * @return int Number of matching rows.
1231:      */
1232:     public static function doCountJoinAllExceptCategory(Criteria $criteria, $distinct = false, PropelPDO $con = null, $join_behavior = Criteria::LEFT_JOIN)
1233:     {
1234:         // we're going to modify criteria, so copy it first
1235:         $criteria = clone $criteria;
1236: 
1237:         // We need to set the primary table name, since in the case that there are no WHERE columns
1238:         // it will be impossible for the BasePeer::createSelectSql() method to determine which
1239:         // tables go into the FROM clause.
1240:         $criteria->setPrimaryTableName(RewritingPeer::TABLE_NAME);
1241: 
1242:         if ($distinct && !in_array(Criteria::DISTINCT, $criteria->getSelectModifiers())) {
1243:             $criteria->setDistinct();
1244:         }
1245: 
1246:         if (!$criteria->hasSelectClause()) {
1247:             RewritingPeer::addSelectColumns($criteria);
1248:         }
1249: 
1250:         $criteria->clearOrderByColumns(); // ORDER BY should not affect count
1251: 
1252:         // Set the correct dbName
1253:         $criteria->setDbName(RewritingPeer::DATABASE_NAME);
1254: 
1255:         if ($con === null) {
1256:             $con = Propel::getConnection(RewritingPeer::DATABASE_NAME, Propel::CONNECTION_READ);
1257:         }
1258: 
1259:         $criteria->addJoin(RewritingPeer::PRODUCT_ID, ProductPeer::ID, $join_behavior);
1260: 
1261:         $criteria->addJoin(RewritingPeer::FOLDER_ID, FolderPeer::ID, $join_behavior);
1262: 
1263:         $criteria->addJoin(RewritingPeer::CONTENT_ID, ContentPeer::ID, $join_behavior);
1264: 
1265:         $stmt = BasePeer::doCount($criteria, $con);
1266: 
1267:         if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
1268:             $count = (int) $row[0];
1269:         } else {
1270:             $count = 0; // no rows returned; we infer that means 0 matches.
1271:         }
1272:         $stmt->closeCursor();
1273: 
1274:         return $count;
1275:     }
1276: 
1277: 
1278:     /**
1279:      * Returns the number of rows matching criteria, joining the related Folder table
1280:      *
1281:      * @param      Criteria $criteria
1282:      * @param      boolean $distinct Whether to select only distinct columns; deprecated: use Criteria->setDistinct() instead.
1283:      * @param      PropelPDO $con
1284:      * @param      String    $join_behavior the type of joins to use, defaults to Criteria::LEFT_JOIN
1285:      * @return int Number of matching rows.
1286:      */
1287:     public static function doCountJoinAllExceptFolder(Criteria $criteria, $distinct = false, PropelPDO $con = null, $join_behavior = Criteria::LEFT_JOIN)
1288:     {
1289:         // we're going to modify criteria, so copy it first
1290:         $criteria = clone $criteria;
1291: 
1292:         // We need to set the primary table name, since in the case that there are no WHERE columns
1293:         // it will be impossible for the BasePeer::createSelectSql() method to determine which
1294:         // tables go into the FROM clause.
1295:         $criteria->setPrimaryTableName(RewritingPeer::TABLE_NAME);
1296: 
1297:         if ($distinct && !in_array(Criteria::DISTINCT, $criteria->getSelectModifiers())) {
1298:             $criteria->setDistinct();
1299:         }
1300: 
1301:         if (!$criteria->hasSelectClause()) {
1302:             RewritingPeer::addSelectColumns($criteria);
1303:         }
1304: 
1305:         $criteria->clearOrderByColumns(); // ORDER BY should not affect count
1306: 
1307:         // Set the correct dbName
1308:         $criteria->setDbName(RewritingPeer::DATABASE_NAME);
1309: 
1310:         if ($con === null) {
1311:             $con = Propel::getConnection(RewritingPeer::DATABASE_NAME, Propel::CONNECTION_READ);
1312:         }
1313: 
1314:         $criteria->addJoin(RewritingPeer::PRODUCT_ID, ProductPeer::ID, $join_behavior);
1315: 
1316:         $criteria->addJoin(RewritingPeer::CATEGORY_ID, CategoryPeer::ID, $join_behavior);
1317: 
1318:         $criteria->addJoin(RewritingPeer::CONTENT_ID, ContentPeer::ID, $join_behavior);
1319: 
1320:         $stmt = BasePeer::doCount($criteria, $con);
1321: 
1322:         if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
1323:             $count = (int) $row[0];
1324:         } else {
1325:             $count = 0; // no rows returned; we infer that means 0 matches.
1326:         }
1327:         $stmt->closeCursor();
1328: 
1329:         return $count;
1330:     }
1331: 
1332: 
1333:     /**
1334:      * Returns the number of rows matching criteria, joining the related Content table
1335:      *
1336:      * @param      Criteria $criteria
1337:      * @param      boolean $distinct Whether to select only distinct columns; deprecated: use Criteria->setDistinct() instead.
1338:      * @param      PropelPDO $con
1339:      * @param      String    $join_behavior the type of joins to use, defaults to Criteria::LEFT_JOIN
1340:      * @return int Number of matching rows.
1341:      */
1342:     public static function doCountJoinAllExceptContent(Criteria $criteria, $distinct = false, PropelPDO $con = null, $join_behavior = Criteria::LEFT_JOIN)
1343:     {
1344:         // we're going to modify criteria, so copy it first
1345:         $criteria = clone $criteria;
1346: 
1347:         // We need to set the primary table name, since in the case that there are no WHERE columns
1348:         // it will be impossible for the BasePeer::createSelectSql() method to determine which
1349:         // tables go into the FROM clause.
1350:         $criteria->setPrimaryTableName(RewritingPeer::TABLE_NAME);
1351: 
1352:         if ($distinct && !in_array(Criteria::DISTINCT, $criteria->getSelectModifiers())) {
1353:             $criteria->setDistinct();
1354:         }
1355: 
1356:         if (!$criteria->hasSelectClause()) {
1357:             RewritingPeer::addSelectColumns($criteria);
1358:         }
1359: 
1360:         $criteria->clearOrderByColumns(); // ORDER BY should not affect count
1361: 
1362:         // Set the correct dbName
1363:         $criteria->setDbName(RewritingPeer::DATABASE_NAME);
1364: 
1365:         if ($con === null) {
1366:             $con = Propel::getConnection(RewritingPeer::DATABASE_NAME, Propel::CONNECTION_READ);
1367:         }
1368: 
1369:         $criteria->addJoin(RewritingPeer::PRODUCT_ID, ProductPeer::ID, $join_behavior);
1370: 
1371:         $criteria->addJoin(RewritingPeer::CATEGORY_ID, CategoryPeer::ID, $join_behavior);
1372: 
1373:         $criteria->addJoin(RewritingPeer::FOLDER_ID, FolderPeer::ID, $join_behavior);
1374: 
1375:         $stmt = BasePeer::doCount($criteria, $con);
1376: 
1377:         if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
1378:             $count = (int) $row[0];
1379:         } else {
1380:             $count = 0; // no rows returned; we infer that means 0 matches.
1381:         }
1382:         $stmt->closeCursor();
1383: 
1384:         return $count;
1385:     }
1386: 
1387: 
1388:     /**
1389:      * Selects a collection of Rewriting objects pre-filled with all related objects except Product.
1390:      *
1391:      * @param      Criteria  $criteria
1392:      * @param      PropelPDO $con
1393:      * @param      String    $join_behavior the type of joins to use, defaults to Criteria::LEFT_JOIN
1394:      * @return array           Array of Rewriting objects.
1395:      * @throws PropelException Any exceptions caught during processing will be
1396:      *       rethrown wrapped into a PropelException.
1397:      */
1398:     public static function doSelectJoinAllExceptProduct(Criteria $criteria, $con = null, $join_behavior = Criteria::LEFT_JOIN)
1399:     {
1400:         $criteria = clone $criteria;
1401: 
1402:         // Set the correct dbName if it has not been overridden
1403:         // $criteria->getDbName() will return the same object if not set to another value
1404:         // so == check is okay and faster
1405:         if ($criteria->getDbName() == Propel::getDefaultDB()) {
1406:             $criteria->setDbName(RewritingPeer::DATABASE_NAME);
1407:         }
1408: 
1409:         RewritingPeer::addSelectColumns($criteria);
1410:         $startcol2 = RewritingPeer::NUM_HYDRATE_COLUMNS;
1411: 
1412:         CategoryPeer::addSelectColumns($criteria);
1413:         $startcol3 = $startcol2 + CategoryPeer::NUM_HYDRATE_COLUMNS;
1414: 
1415:         FolderPeer::addSelectColumns($criteria);
1416:         $startcol4 = $startcol3 + FolderPeer::NUM_HYDRATE_COLUMNS;
1417: 
1418:         ContentPeer::addSelectColumns($criteria);
1419:         $startcol5 = $startcol4 + ContentPeer::NUM_HYDRATE_COLUMNS;
1420: 
1421:         $criteria->addJoin(RewritingPeer::CATEGORY_ID, CategoryPeer::ID, $join_behavior);
1422: 
1423:         $criteria->addJoin(RewritingPeer::FOLDER_ID, FolderPeer::ID, $join_behavior);
1424: 
1425:         $criteria->addJoin(RewritingPeer::CONTENT_ID, ContentPeer::ID, $join_behavior);
1426: 
1427: 
1428:         $stmt = BasePeer::doSelect($criteria, $con);
1429:         $results = array();
1430: 
1431:         while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
1432:             $key1 = RewritingPeer::getPrimaryKeyHashFromRow($row, 0);
1433:             if (null !== ($obj1 = RewritingPeer::getInstanceFromPool($key1))) {
1434:                 // We no longer rehydrate the object, since this can cause data loss.
1435:                 // See http://www.propelorm.org/ticket/509
1436:                 // $obj1->hydrate($row, 0, true); // rehydrate
1437:             } else {
1438:                 $cls = RewritingPeer::getOMClass();
1439: 
1440:                 $obj1 = new $cls();
1441:                 $obj1->hydrate($row);
1442:                 RewritingPeer::addInstanceToPool($obj1, $key1);
1443:             } // if obj1 already loaded
1444: 
1445:                 // Add objects for joined Category rows
1446: 
1447:                 $key2 = CategoryPeer::getPrimaryKeyHashFromRow($row, $startcol2);
1448:                 if ($key2 !== null) {
1449:                     $obj2 = CategoryPeer::getInstanceFromPool($key2);
1450:                     if (!$obj2) {
1451: 
1452:                         $cls = CategoryPeer::getOMClass();
1453: 
1454:                     $obj2 = new $cls();
1455:                     $obj2->hydrate($row, $startcol2);
1456:                     CategoryPeer::addInstanceToPool($obj2, $key2);
1457:                 } // if $obj2 already loaded
1458: 
1459:                 // Add the $obj1 (Rewriting) to the collection in $obj2 (Category)
1460:                 $obj2->addRewriting($obj1);
1461: 
1462:             } // if joined row is not null
1463: 
1464:                 // Add objects for joined Folder rows
1465: 
1466:                 $key3 = FolderPeer::getPrimaryKeyHashFromRow($row, $startcol3);
1467:                 if ($key3 !== null) {
1468:                     $obj3 = FolderPeer::getInstanceFromPool($key3);
1469:                     if (!$obj3) {
1470: 
1471:                         $cls = FolderPeer::getOMClass();
1472: 
1473:                     $obj3 = new $cls();
1474:                     $obj3->hydrate($row, $startcol3);
1475:                     FolderPeer::addInstanceToPool($obj3, $key3);
1476:                 } // if $obj3 already loaded
1477: 
1478:                 // Add the $obj1 (Rewriting) to the collection in $obj3 (Folder)
1479:                 $obj3->addRewriting($obj1);
1480: 
1481:             } // if joined row is not null
1482: 
1483:                 // Add objects for joined Content rows
1484: 
1485:                 $key4 = ContentPeer::getPrimaryKeyHashFromRow($row, $startcol4);
1486:                 if ($key4 !== null) {
1487:                     $obj4 = ContentPeer::getInstanceFromPool($key4);
1488:                     if (!$obj4) {
1489: 
1490:                         $cls = ContentPeer::getOMClass();
1491: 
1492:                     $obj4 = new $cls();
1493:                     $obj4->hydrate($row, $startcol4);
1494:                     ContentPeer::addInstanceToPool($obj4, $key4);
1495:                 } // if $obj4 already loaded
1496: 
1497:                 // Add the $obj1 (Rewriting) to the collection in $obj4 (Content)
1498:                 $obj4->addRewriting($obj1);
1499: 
1500:             } // if joined row is not null
1501: 
1502:             $results[] = $obj1;
1503:         }
1504:         $stmt->closeCursor();
1505: 
1506:         return $results;
1507:     }
1508: 
1509: 
1510:     /**
1511:      * Selects a collection of Rewriting objects pre-filled with all related objects except Category.
1512:      *
1513:      * @param      Criteria  $criteria
1514:      * @param      PropelPDO $con
1515:      * @param      String    $join_behavior the type of joins to use, defaults to Criteria::LEFT_JOIN
1516:      * @return array           Array of Rewriting objects.
1517:      * @throws PropelException Any exceptions caught during processing will be
1518:      *       rethrown wrapped into a PropelException.
1519:      */
1520:     public static function doSelectJoinAllExceptCategory(Criteria $criteria, $con = null, $join_behavior = Criteria::LEFT_JOIN)
1521:     {
1522:         $criteria = clone $criteria;
1523: 
1524:         // Set the correct dbName if it has not been overridden
1525:         // $criteria->getDbName() will return the same object if not set to another value
1526:         // so == check is okay and faster
1527:         if ($criteria->getDbName() == Propel::getDefaultDB()) {
1528:             $criteria->setDbName(RewritingPeer::DATABASE_NAME);
1529:         }
1530: 
1531:         RewritingPeer::addSelectColumns($criteria);
1532:         $startcol2 = RewritingPeer::NUM_HYDRATE_COLUMNS;
1533: 
1534:         ProductPeer::addSelectColumns($criteria);
1535:         $startcol3 = $startcol2 + ProductPeer::NUM_HYDRATE_COLUMNS;
1536: 
1537:         FolderPeer::addSelectColumns($criteria);
1538:         $startcol4 = $startcol3 + FolderPeer::NUM_HYDRATE_COLUMNS;
1539: 
1540:         ContentPeer::addSelectColumns($criteria);
1541:         $startcol5 = $startcol4 + ContentPeer::NUM_HYDRATE_COLUMNS;
1542: 
1543:         $criteria->addJoin(RewritingPeer::PRODUCT_ID, ProductPeer::ID, $join_behavior);
1544: 
1545:         $criteria->addJoin(RewritingPeer::FOLDER_ID, FolderPeer::ID, $join_behavior);
1546: 
1547:         $criteria->addJoin(RewritingPeer::CONTENT_ID, ContentPeer::ID, $join_behavior);
1548: 
1549: 
1550:         $stmt = BasePeer::doSelect($criteria, $con);
1551:         $results = array();
1552: 
1553:         while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
1554:             $key1 = RewritingPeer::getPrimaryKeyHashFromRow($row, 0);
1555:             if (null !== ($obj1 = RewritingPeer::getInstanceFromPool($key1))) {
1556:                 // We no longer rehydrate the object, since this can cause data loss.
1557:                 // See http://www.propelorm.org/ticket/509
1558:                 // $obj1->hydrate($row, 0, true); // rehydrate
1559:             } else {
1560:                 $cls = RewritingPeer::getOMClass();
1561: 
1562:                 $obj1 = new $cls();
1563:                 $obj1->hydrate($row);
1564:                 RewritingPeer::addInstanceToPool($obj1, $key1);
1565:             } // if obj1 already loaded
1566: 
1567:                 // Add objects for joined Product rows
1568: 
1569:                 $key2 = ProductPeer::getPrimaryKeyHashFromRow($row, $startcol2);
1570:                 if ($key2 !== null) {
1571:                     $obj2 = ProductPeer::getInstanceFromPool($key2);
1572:                     if (!$obj2) {
1573: 
1574:                         $cls = ProductPeer::getOMClass();
1575: 
1576:                     $obj2 = new $cls();
1577:                     $obj2->hydrate($row, $startcol2);
1578:                     ProductPeer::addInstanceToPool($obj2, $key2);
1579:                 } // if $obj2 already loaded
1580: 
1581:                 // Add the $obj1 (Rewriting) to the collection in $obj2 (Product)
1582:                 $obj2->addRewriting($obj1);
1583: 
1584:             } // if joined row is not null
1585: 
1586:                 // Add objects for joined Folder rows
1587: 
1588:                 $key3 = FolderPeer::getPrimaryKeyHashFromRow($row, $startcol3);
1589:                 if ($key3 !== null) {
1590:                     $obj3 = FolderPeer::getInstanceFromPool($key3);
1591:                     if (!$obj3) {
1592: 
1593:                         $cls = FolderPeer::getOMClass();
1594: 
1595:                     $obj3 = new $cls();
1596:                     $obj3->hydrate($row, $startcol3);
1597:                     FolderPeer::addInstanceToPool($obj3, $key3);
1598:                 } // if $obj3 already loaded
1599: 
1600:                 // Add the $obj1 (Rewriting) to the collection in $obj3 (Folder)
1601:                 $obj3->addRewriting($obj1);
1602: 
1603:             } // if joined row is not null
1604: 
1605:                 // Add objects for joined Content rows
1606: 
1607:                 $key4 = ContentPeer::getPrimaryKeyHashFromRow($row, $startcol4);
1608:                 if ($key4 !== null) {
1609:                     $obj4 = ContentPeer::getInstanceFromPool($key4);
1610:                     if (!$obj4) {
1611: 
1612:                         $cls = ContentPeer::getOMClass();
1613: 
1614:                     $obj4 = new $cls();
1615:                     $obj4->hydrate($row, $startcol4);
1616:                     ContentPeer::addInstanceToPool($obj4, $key4);
1617:                 } // if $obj4 already loaded
1618: 
1619:                 // Add the $obj1 (Rewriting) to the collection in $obj4 (Content)
1620:                 $obj4->addRewriting($obj1);
1621: 
1622:             } // if joined row is not null
1623: 
1624:             $results[] = $obj1;
1625:         }
1626:         $stmt->closeCursor();
1627: 
1628:         return $results;
1629:     }
1630: 
1631: 
1632:     /**
1633:      * Selects a collection of Rewriting objects pre-filled with all related objects except Folder.
1634:      *
1635:      * @param      Criteria  $criteria
1636:      * @param      PropelPDO $con
1637:      * @param      String    $join_behavior the type of joins to use, defaults to Criteria::LEFT_JOIN
1638:      * @return array           Array of Rewriting objects.
1639:      * @throws PropelException Any exceptions caught during processing will be
1640:      *       rethrown wrapped into a PropelException.
1641:      */
1642:     public static function doSelectJoinAllExceptFolder(Criteria $criteria, $con = null, $join_behavior = Criteria::LEFT_JOIN)
1643:     {
1644:         $criteria = clone $criteria;
1645: 
1646:         // Set the correct dbName if it has not been overridden
1647:         // $criteria->getDbName() will return the same object if not set to another value
1648:         // so == check is okay and faster
1649:         if ($criteria->getDbName() == Propel::getDefaultDB()) {
1650:             $criteria->setDbName(RewritingPeer::DATABASE_NAME);
1651:         }
1652: 
1653:         RewritingPeer::addSelectColumns($criteria);
1654:         $startcol2 = RewritingPeer::NUM_HYDRATE_COLUMNS;
1655: 
1656:         ProductPeer::addSelectColumns($criteria);
1657:         $startcol3 = $startcol2 + ProductPeer::NUM_HYDRATE_COLUMNS;
1658: 
1659:         CategoryPeer::addSelectColumns($criteria);
1660:         $startcol4 = $startcol3 + CategoryPeer::NUM_HYDRATE_COLUMNS;
1661: 
1662:         ContentPeer::addSelectColumns($criteria);
1663:         $startcol5 = $startcol4 + ContentPeer::NUM_HYDRATE_COLUMNS;
1664: 
1665:         $criteria->addJoin(RewritingPeer::PRODUCT_ID, ProductPeer::ID, $join_behavior);
1666: 
1667:         $criteria->addJoin(RewritingPeer::CATEGORY_ID, CategoryPeer::ID, $join_behavior);
1668: 
1669:         $criteria->addJoin(RewritingPeer::CONTENT_ID, ContentPeer::ID, $join_behavior);
1670: 
1671: 
1672:         $stmt = BasePeer::doSelect($criteria, $con);
1673:         $results = array();
1674: 
1675:         while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
1676:             $key1 = RewritingPeer::getPrimaryKeyHashFromRow($row, 0);
1677:             if (null !== ($obj1 = RewritingPeer::getInstanceFromPool($key1))) {
1678:                 // We no longer rehydrate the object, since this can cause data loss.
1679:                 // See http://www.propelorm.org/ticket/509
1680:                 // $obj1->hydrate($row, 0, true); // rehydrate
1681:             } else {
1682:                 $cls = RewritingPeer::getOMClass();
1683: 
1684:                 $obj1 = new $cls();
1685:                 $obj1->hydrate($row);
1686:                 RewritingPeer::addInstanceToPool($obj1, $key1);
1687:             } // if obj1 already loaded
1688: 
1689:                 // Add objects for joined Product rows
1690: 
1691:                 $key2 = ProductPeer::getPrimaryKeyHashFromRow($row, $startcol2);
1692:                 if ($key2 !== null) {
1693:                     $obj2 = ProductPeer::getInstanceFromPool($key2);
1694:                     if (!$obj2) {
1695: 
1696:                         $cls = ProductPeer::getOMClass();
1697: 
1698:                     $obj2 = new $cls();
1699:                     $obj2->hydrate($row, $startcol2);
1700:                     ProductPeer::addInstanceToPool($obj2, $key2);
1701:                 } // if $obj2 already loaded
1702: 
1703:                 // Add the $obj1 (Rewriting) to the collection in $obj2 (Product)
1704:                 $obj2->addRewriting($obj1);
1705: 
1706:             } // if joined row is not null
1707: 
1708:                 // Add objects for joined Category rows
1709: 
1710:                 $key3 = CategoryPeer::getPrimaryKeyHashFromRow($row, $startcol3);
1711:                 if ($key3 !== null) {
1712:                     $obj3 = CategoryPeer::getInstanceFromPool($key3);
1713:                     if (!$obj3) {
1714: 
1715:                         $cls = CategoryPeer::getOMClass();
1716: 
1717:                     $obj3 = new $cls();
1718:                     $obj3->hydrate($row, $startcol3);
1719:                     CategoryPeer::addInstanceToPool($obj3, $key3);
1720:                 } // if $obj3 already loaded
1721: 
1722:                 // Add the $obj1 (Rewriting) to the collection in $obj3 (Category)
1723:                 $obj3->addRewriting($obj1);
1724: 
1725:             } // if joined row is not null
1726: 
1727:                 // Add objects for joined Content rows
1728: 
1729:                 $key4 = ContentPeer::getPrimaryKeyHashFromRow($row, $startcol4);
1730:                 if ($key4 !== null) {
1731:                     $obj4 = ContentPeer::getInstanceFromPool($key4);
1732:                     if (!$obj4) {
1733: 
1734:                         $cls = ContentPeer::getOMClass();
1735: 
1736:                     $obj4 = new $cls();
1737:                     $obj4->hydrate($row, $startcol4);
1738:                     ContentPeer::addInstanceToPool($obj4, $key4);
1739:                 } // if $obj4 already loaded
1740: 
1741:                 // Add the $obj1 (Rewriting) to the collection in $obj4 (Content)
1742:                 $obj4->addRewriting($obj1);
1743: 
1744:             } // if joined row is not null
1745: 
1746:             $results[] = $obj1;
1747:         }
1748:         $stmt->closeCursor();
1749: 
1750:         return $results;
1751:     }
1752: 
1753: 
1754:     /**
1755:      * Selects a collection of Rewriting objects pre-filled with all related objects except Content.
1756:      *
1757:      * @param      Criteria  $criteria
1758:      * @param      PropelPDO $con
1759:      * @param      String    $join_behavior the type of joins to use, defaults to Criteria::LEFT_JOIN
1760:      * @return array           Array of Rewriting objects.
1761:      * @throws PropelException Any exceptions caught during processing will be
1762:      *       rethrown wrapped into a PropelException.
1763:      */
1764:     public static function doSelectJoinAllExceptContent(Criteria $criteria, $con = null, $join_behavior = Criteria::LEFT_JOIN)
1765:     {
1766:         $criteria = clone $criteria;
1767: 
1768:         // Set the correct dbName if it has not been overridden
1769:         // $criteria->getDbName() will return the same object if not set to another value
1770:         // so == check is okay and faster
1771:         if ($criteria->getDbName() == Propel::getDefaultDB()) {
1772:             $criteria->setDbName(RewritingPeer::DATABASE_NAME);
1773:         }
1774: 
1775:         RewritingPeer::addSelectColumns($criteria);
1776:         $startcol2 = RewritingPeer::NUM_HYDRATE_COLUMNS;
1777: 
1778:         ProductPeer::addSelectColumns($criteria);
1779:         $startcol3 = $startcol2 + ProductPeer::NUM_HYDRATE_COLUMNS;
1780: 
1781:         CategoryPeer::addSelectColumns($criteria);
1782:         $startcol4 = $startcol3 + CategoryPeer::NUM_HYDRATE_COLUMNS;
1783: 
1784:         FolderPeer::addSelectColumns($criteria);
1785:         $startcol5 = $startcol4 + FolderPeer::NUM_HYDRATE_COLUMNS;
1786: 
1787:         $criteria->addJoin(RewritingPeer::PRODUCT_ID, ProductPeer::ID, $join_behavior);
1788: 
1789:         $criteria->addJoin(RewritingPeer::CATEGORY_ID, CategoryPeer::ID, $join_behavior);
1790: 
1791:         $criteria->addJoin(RewritingPeer::FOLDER_ID, FolderPeer::ID, $join_behavior);
1792: 
1793: 
1794:         $stmt = BasePeer::doSelect($criteria, $con);
1795:         $results = array();
1796: 
1797:         while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
1798:             $key1 = RewritingPeer::getPrimaryKeyHashFromRow($row, 0);
1799:             if (null !== ($obj1 = RewritingPeer::getInstanceFromPool($key1))) {
1800:                 // We no longer rehydrate the object, since this can cause data loss.
1801:                 // See http://www.propelorm.org/ticket/509
1802:                 // $obj1->hydrate($row, 0, true); // rehydrate
1803:             } else {
1804:                 $cls = RewritingPeer::getOMClass();
1805: 
1806:                 $obj1 = new $cls();
1807:                 $obj1->hydrate($row);
1808:                 RewritingPeer::addInstanceToPool($obj1, $key1);
1809:             } // if obj1 already loaded
1810: 
1811:                 // Add objects for joined Product rows
1812: 
1813:                 $key2 = ProductPeer::getPrimaryKeyHashFromRow($row, $startcol2);
1814:                 if ($key2 !== null) {
1815:                     $obj2 = ProductPeer::getInstanceFromPool($key2);
1816:                     if (!$obj2) {
1817: 
1818:                         $cls = ProductPeer::getOMClass();
1819: 
1820:                     $obj2 = new $cls();
1821:                     $obj2->hydrate($row, $startcol2);
1822:                     ProductPeer::addInstanceToPool($obj2, $key2);
1823:                 } // if $obj2 already loaded
1824: 
1825:                 // Add the $obj1 (Rewriting) to the collection in $obj2 (Product)
1826:                 $obj2->addRewriting($obj1);
1827: 
1828:             } // if joined row is not null
1829: 
1830:                 // Add objects for joined Category rows
1831: 
1832:                 $key3 = CategoryPeer::getPrimaryKeyHashFromRow($row, $startcol3);
1833:                 if ($key3 !== null) {
1834:                     $obj3 = CategoryPeer::getInstanceFromPool($key3);
1835:                     if (!$obj3) {
1836: 
1837:                         $cls = CategoryPeer::getOMClass();
1838: 
1839:                     $obj3 = new $cls();
1840:                     $obj3->hydrate($row, $startcol3);
1841:                     CategoryPeer::addInstanceToPool($obj3, $key3);
1842:                 } // if $obj3 already loaded
1843: 
1844:                 // Add the $obj1 (Rewriting) to the collection in $obj3 (Category)
1845:                 $obj3->addRewriting($obj1);
1846: 
1847:             } // if joined row is not null
1848: 
1849:                 // Add objects for joined Folder rows
1850: 
1851:                 $key4 = FolderPeer::getPrimaryKeyHashFromRow($row, $startcol4);
1852:                 if ($key4 !== null) {
1853:                     $obj4 = FolderPeer::getInstanceFromPool($key4);
1854:                     if (!$obj4) {
1855: 
1856:                         $cls = FolderPeer::getOMClass();
1857: 
1858:                     $obj4 = new $cls();
1859:                     $obj4->hydrate($row, $startcol4);
1860:                     FolderPeer::addInstanceToPool($obj4, $key4);
1861:                 } // if $obj4 already loaded
1862: 
1863:                 // Add the $obj1 (Rewriting) to the collection in $obj4 (Folder)
1864:                 $obj4->addRewriting($obj1);
1865: 
1866:             } // if joined row is not null
1867: 
1868:             $results[] = $obj1;
1869:         }
1870:         $stmt->closeCursor();
1871: 
1872:         return $results;
1873:     }
1874: 
1875:     /**
1876:      * Returns the TableMap related to this peer.
1877:      * This method is not needed for general use but a specific application could have a need.
1878:      * @return TableMap
1879:      * @throws PropelException Any exceptions caught during processing will be
1880:      *       rethrown wrapped into a PropelException.
1881:      */
1882:     public static function getTableMap()
1883:     {
1884:         return Propel::getDatabaseMap(RewritingPeer::DATABASE_NAME)->getTable(RewritingPeer::TABLE_NAME);
1885:     }
1886: 
1887:     /**
1888:      * Add a TableMap instance to the database for this peer class.
1889:      */
1890:     public static function buildTableMap()
1891:     {
1892:       $dbMap = Propel::getDatabaseMap(BaseRewritingPeer::DATABASE_NAME);
1893:       if (!$dbMap->hasTable(BaseRewritingPeer::TABLE_NAME)) {
1894:         $dbMap->addTableObject(new RewritingTableMap());
1895:       }
1896:     }
1897: 
1898:     /**
1899:      * The class that the Peer will make instances of.
1900:      *
1901:      *
1902:      * @return string ClassName
1903:      */
1904:     public static function getOMClass()
1905:     {
1906:         return RewritingPeer::OM_CLASS;
1907:     }
1908: 
1909:     /**
1910:      * Performs an INSERT on the database, given a Rewriting or Criteria object.
1911:      *
1912:      * @param      mixed $values Criteria or Rewriting object containing data that is used to create the INSERT statement.
1913:      * @param      PropelPDO $con the PropelPDO connection to use
1914:      * @return mixed           The new primary key.
1915:      * @throws PropelException Any exceptions caught during processing will be
1916:      *       rethrown wrapped into a PropelException.
1917:      */
1918:     public static function doInsert($values, PropelPDO $con = null)
1919:     {
1920:         if ($con === null) {
1921:             $con = Propel::getConnection(RewritingPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
1922:         }
1923: 
1924:         if ($values instanceof Criteria) {
1925:             $criteria = clone $values; // rename for clarity
1926:         } else {
1927:             $criteria = $values->buildCriteria(); // build Criteria from Rewriting object
1928:         }
1929: 
1930: 
1931:         // Set the correct dbName
1932:         $criteria->setDbName(RewritingPeer::DATABASE_NAME);
1933: 
1934:         try {
1935:             // use transaction because $criteria could contain info
1936:             // for more than one table (I guess, conceivably)
1937:             $con->beginTransaction();
1938:             $pk = BasePeer::doInsert($criteria, $con);
1939:             $con->commit();
1940:         } catch (PropelException $e) {
1941:             $con->rollBack();
1942:             throw $e;
1943:         }
1944: 
1945:         return $pk;
1946:     }
1947: 
1948:     /**
1949:      * Performs an UPDATE on the database, given a Rewriting or Criteria object.
1950:      *
1951:      * @param      mixed $values Criteria or Rewriting object containing data that is used to create the UPDATE statement.
1952:      * @param      PropelPDO $con The connection to use (specify PropelPDO connection object to exert more control over transactions).
1953:      * @return int             The number of affected rows (if supported by underlying database driver).
1954:      * @throws PropelException Any exceptions caught during processing will be
1955:      *       rethrown wrapped into a PropelException.
1956:      */
1957:     public static function doUpdate($values, PropelPDO $con = null)
1958:     {
1959:         if ($con === null) {
1960:             $con = Propel::getConnection(RewritingPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
1961:         }
1962: 
1963:         $selectCriteria = new Criteria(RewritingPeer::DATABASE_NAME);
1964: 
1965:         if ($values instanceof Criteria) {
1966:             $criteria = clone $values; // rename for clarity
1967: 
1968:             $comparison = $criteria->getComparison(RewritingPeer::ID);
1969:             $value = $criteria->remove(RewritingPeer::ID);
1970:             if ($value) {
1971:                 $selectCriteria->add(RewritingPeer::ID, $value, $comparison);
1972:             } else {
1973:                 $selectCriteria->setPrimaryTableName(RewritingPeer::TABLE_NAME);
1974:             }
1975: 
1976:         } else { // $values is Rewriting object
1977:             $criteria = $values->buildCriteria(); // gets full criteria
1978:             $selectCriteria = $values->buildPkeyCriteria(); // gets criteria w/ primary key(s)
1979:         }
1980: 
1981:         // set the correct dbName
1982:         $criteria->setDbName(RewritingPeer::DATABASE_NAME);
1983: 
1984:         return BasePeer::doUpdate($selectCriteria, $criteria, $con);
1985:     }
1986: 
1987:     /**
1988:      * Deletes all rows from the rewriting table.
1989:      *
1990:      * @param      PropelPDO $con the connection to use
1991:      * @return int             The number of affected rows (if supported by underlying database driver).
1992:      * @throws PropelException
1993:      */
1994:     public static function doDeleteAll(PropelPDO $con = null)
1995:     {
1996:         if ($con === null) {
1997:             $con = Propel::getConnection(RewritingPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
1998:         }
1999:         $affectedRows = 0; // initialize var to track total num of affected rows
2000:         try {
2001:             // use transaction because $criteria could contain info
2002:             // for more than one table or we could emulating ON DELETE CASCADE, etc.
2003:             $con->beginTransaction();
2004:             $affectedRows += BasePeer::doDeleteAll(RewritingPeer::TABLE_NAME, $con, RewritingPeer::DATABASE_NAME);
2005:             // Because this db requires some delete cascade/set null emulation, we have to
2006:             // clear the cached instance *after* the emulation has happened (since
2007:             // instances get re-added by the select statement contained therein).
2008:             RewritingPeer::clearInstancePool();
2009:             RewritingPeer::clearRelatedInstancePool();
2010:             $con->commit();
2011: 
2012:             return $affectedRows;
2013:         } catch (PropelException $e) {
2014:             $con->rollBack();
2015:             throw $e;
2016:         }
2017:     }
2018: 
2019:     /**
2020:      * Performs a DELETE on the database, given a Rewriting or Criteria object OR a primary key value.
2021:      *
2022:      * @param      mixed $values Criteria or Rewriting object or primary key or array of primary keys
2023:      *              which is used to create the DELETE statement
2024:      * @param      PropelPDO $con the connection to use
2025:      * @return int The number of affected rows (if supported by underlying database driver).  This includes CASCADE-related rows
2026:      *              if supported by native driver or if emulated using Propel.
2027:      * @throws PropelException Any exceptions caught during processing will be
2028:      *       rethrown wrapped into a PropelException.
2029:      */
2030:      public static function doDelete($values, PropelPDO $con = null)
2031:      {
2032:         if ($con === null) {
2033:             $con = Propel::getConnection(RewritingPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
2034:         }
2035: 
2036:         if ($values instanceof Criteria) {
2037:             // invalidate the cache for all objects of this type, since we have no
2038:             // way of knowing (without running a query) what objects should be invalidated
2039:             // from the cache based on this Criteria.
2040:             RewritingPeer::clearInstancePool();
2041:             // rename for clarity
2042:             $criteria = clone $values;
2043:         } elseif ($values instanceof Rewriting) { // it's a model object
2044:             // invalidate the cache for this single object
2045:             RewritingPeer::removeInstanceFromPool($values);
2046:             // create criteria based on pk values
2047:             $criteria = $values->buildPkeyCriteria();
2048:         } else { // it's a primary key, or an array of pks
2049:             $criteria = new Criteria(RewritingPeer::DATABASE_NAME);
2050:             $criteria->add(RewritingPeer::ID, (array) $values, Criteria::IN);
2051:             // invalidate the cache for this object(s)
2052:             foreach ((array) $values as $singleval) {
2053:                 RewritingPeer::removeInstanceFromPool($singleval);
2054:             }
2055:         }
2056: 
2057:         // Set the correct dbName
2058:         $criteria->setDbName(RewritingPeer::DATABASE_NAME);
2059: 
2060:         $affectedRows = 0; // initialize var to track total num of affected rows
2061: 
2062:         try {
2063:             // use transaction because $criteria could contain info
2064:             // for more than one table or we could emulating ON DELETE CASCADE, etc.
2065:             $con->beginTransaction();
2066: 
2067:             $affectedRows += BasePeer::doDelete($criteria, $con);
2068:             RewritingPeer::clearRelatedInstancePool();
2069:             $con->commit();
2070: 
2071:             return $affectedRows;
2072:         } catch (PropelException $e) {
2073:             $con->rollBack();
2074:             throw $e;
2075:         }
2076:     }
2077: 
2078:     /**
2079:      * Validates all modified columns of given Rewriting object.
2080:      * If parameter $columns is either a single column name or an array of column names
2081:      * than only those columns are validated.
2082:      *
2083:      * NOTICE: This does not apply to primary or foreign keys for now.
2084:      *
2085:      * @param      Rewriting $obj The object to validate.
2086:      * @param      mixed $cols Column name or array of column names.
2087:      *
2088:      * @return mixed TRUE if all columns are valid or the error message of the first invalid column.
2089:      */
2090:     public static function doValidate($obj, $cols = null)
2091:     {
2092:         $columns = array();
2093: 
2094:         if ($cols) {
2095:             $dbMap = Propel::getDatabaseMap(RewritingPeer::DATABASE_NAME);
2096:             $tableMap = $dbMap->getTable(RewritingPeer::TABLE_NAME);
2097: 
2098:             if (! is_array($cols)) {
2099:                 $cols = array($cols);
2100:             }
2101: 
2102:             foreach ($cols as $colName) {
2103:                 if ($tableMap->hasColumn($colName)) {
2104:                     $get = 'get' . $tableMap->getColumn($colName)->getPhpName();
2105:                     $columns[$colName] = $obj->$get();
2106:                 }
2107:             }
2108:         } else {
2109: 
2110:         }
2111: 
2112:         return BasePeer::doValidate(RewritingPeer::DATABASE_NAME, RewritingPeer::TABLE_NAME, $columns);
2113:     }
2114: 
2115:     /**
2116:      * Retrieve a single object by pkey.
2117:      *
2118:      * @param      int $pk the primary key.
2119:      * @param      PropelPDO $con the connection to use
2120:      * @return Rewriting
2121:      */
2122:     public static function retrieveByPK($pk, PropelPDO $con = null)
2123:     {
2124: 
2125:         if (null !== ($obj = RewritingPeer::getInstanceFromPool((string) $pk))) {
2126:             return $obj;
2127:         }
2128: 
2129:         if ($con === null) {
2130:             $con = Propel::getConnection(RewritingPeer::DATABASE_NAME, Propel::CONNECTION_READ);
2131:         }
2132: 
2133:         $criteria = new Criteria(RewritingPeer::DATABASE_NAME);
2134:         $criteria->add(RewritingPeer::ID, $pk);
2135: 
2136:         $v = RewritingPeer::doSelect($criteria, $con);
2137: 
2138:         return !empty($v) > 0 ? $v[0] : null;
2139:     }
2140: 
2141:     /**
2142:      * Retrieve multiple objects by pkey.
2143:      *
2144:      * @param      array $pks List of primary keys
2145:      * @param      PropelPDO $con the connection to use
2146:      * @return Rewriting[]
2147:      * @throws PropelException Any exceptions caught during processing will be
2148:      *       rethrown wrapped into a PropelException.
2149:      */
2150:     public static function retrieveByPKs($pks, PropelPDO $con = null)
2151:     {
2152:         if ($con === null) {
2153:             $con = Propel::getConnection(RewritingPeer::DATABASE_NAME, Propel::CONNECTION_READ);
2154:         }
2155: 
2156:         $objs = null;
2157:         if (empty($pks)) {
2158:             $objs = array();
2159:         } else {
2160:             $criteria = new Criteria(RewritingPeer::DATABASE_NAME);
2161:             $criteria->add(RewritingPeer::ID, $pks, Criteria::IN);
2162:             $objs = RewritingPeer::doSelect($criteria, $con);
2163:         }
2164: 
2165:         return $objs;
2166:     }
2167: 
2168: } // BaseRewritingPeer
2169: 
2170: // This is the static code needed to register the TableMap for this table with the main Propel class.
2171: //
2172: BaseRewritingPeer::buildTableMap();
2173: 
2174: