# File core/lib/Thelia/Model/om/BaseDocumentPeer.php | thelia

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