       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\MessagePeer;
      13: use Thelia\Model\MessageVersion;
      14: use Thelia\Model\MessageVersionPeer;
      15: use Thelia\Model\map\MessageVersionTableMap;
      16:
      17: /**
      18:  * Base static class for performing query and update operations on the 'message_version' table.
      19:  *
      20:  *
      21:  *
      22:  * @package propel.generator.Thelia.Model.om
      23:  */
      24: abstract class BaseMessageVersionPeer
      25: {
      26:
      27:     /** the default database name for this class */
      28:     const DATABASE_NAME = 'thelia';
      29:
      30:     /** the table name for this class */
      31:     const TABLE_NAME = 'message_version';
      32:
      33:     /** the related Propel class for this table */
      34:     const OM_CLASS = 'Thelia\\Model\\MessageVersion';
      35:
      36:     /** the related TableMap class for this table */
      37:     const TM_CLASS = 'MessageVersionTableMap';
      38:
      39:     /** The total number of columns. */
      40:     const NUM_COLUMNS = 9;
      41:
      42:     /** The number of lazy-loaded columns. */
      43:     const NUM_LAZY_LOAD_COLUMNS = 0;
      44:
      45:     /** The number of columns to hydrate (NUM_COLUMNS - NUM_LAZY_LOAD_COLUMNS) */
      46:     const NUM_HYDRATE_COLUMNS = 9;
      47:
      48:     /** the column name for the id field */
      49:     const ID = 'message_version.id';
      50:
      51:     /** the column name for the code field */
      52:     const CODE = 'message_version.code';
      53:
      54:     /** the column name for the secured field */
      55:     const SECURED = 'message_version.secured';
      56:
      57:     /** the column name for the ref field */
      58:     const REF = 'message_version.ref';
      59:
      60:     /** the column name for the created_at field */
      61:     const CREATED_AT = 'message_version.created_at';
      62:
      63:     /** the column name for the updated_at field */
      64:     const UPDATED_AT = 'message_version.updated_at';
      65:
      66:     /** the column name for the version field */
      67:     const VERSION = 'message_version.version';
      68:
      69:     /** the column name for the version_created_at field */
      70:     const VERSION_CREATED_AT = 'message_version.version_created_at';
      71:
      72:     /** the column name for the version_created_by field */
      73:     const VERSION_CREATED_BY = 'message_version.version_created_by';
      74:
      75:     /** The default string format for model objects of the related table **/
      76:     const DEFAULT_STRING_FORMAT = 'YAML';
      77:
      78:     /**
      79:      * An identiy map to hold any loaded instances of MessageVersion objects.
      80:      * This must be public so that other peer classes can access this when hydrating from JOIN
      81:      * queries.
      82:      * @var        array MessageVersion[]
      83:      */
      84:     public static $instances = array();
      85:
      86:
      87:     /**
      88:      * holds an array of fieldnames
      89:      *
      90:      * first dimension keys are the type constants
      91:      * e.g. MessageVersionPeer::$fieldNames[MessageVersionPeer::TYPE_PHPNAME][0] = 'Id'
      92:      */
      93:     protected static $fieldNames = array (
      94:         BasePeer::TYPE_PHPNAME => array ('Id', 'Code', 'Secured', 'Ref', 'CreatedAt', 'UpdatedAt', 'Version', 'VersionCreatedAt', 'VersionCreatedBy', ),
      95:         BasePeer::TYPE_STUDLYPHPNAME => array ('id', 'code', 'secured', 'ref', 'createdAt', 'updatedAt', 'version', 'versionCreatedAt', 'versionCreatedBy', ),
      96:         BasePeer::TYPE_COLNAME => array (MessageVersionPeer::ID, MessageVersionPeer::CODE, MessageVersionPeer::SECURED, MessageVersionPeer::REF, MessageVersionPeer::CREATED_AT, MessageVersionPeer::UPDATED_AT, MessageVersionPeer::VERSION, MessageVersionPeer::VERSION_CREATED_AT, MessageVersionPeer::VERSION_CREATED_BY, ),
      97:         BasePeer::TYPE_RAW_COLNAME => array ('ID', 'CODE', 'SECURED', 'REF', 'CREATED_AT', 'UPDATED_AT', 'VERSION', 'VERSION_CREATED_AT', 'VERSION_CREATED_BY', ),
      98:         BasePeer::TYPE_FIELDNAME => array ('id', 'code', 'secured', 'ref', 'created_at', 'updated_at', 'version', 'version_created_at', 'version_created_by', ),
      99:         BasePeer::TYPE_NUM => array (0, 1, 2, 3, 4, 5, 6, 7, 8, )
     100:     );
     101:
     102:     /**
     103:      * holds an array of keys for quick access to the fieldnames array
     104:      *
     105:      * first dimension keys are the type constants
     106:      * e.g. MessageVersionPeer::$fieldNames[BasePeer::TYPE_PHPNAME]['Id'] = 0
     107:      */
     108:     protected static $fieldKeys = array (
     109:         BasePeer::TYPE_PHPNAME => array ('Id' => 0, 'Code' => 1, 'Secured' => 2, 'Ref' => 3, 'CreatedAt' => 4, 'UpdatedAt' => 5, 'Version' => 6, 'VersionCreatedAt' => 7, 'VersionCreatedBy' => 8, ),
     110:         BasePeer::TYPE_STUDLYPHPNAME => array ('id' => 0, 'code' => 1, 'secured' => 2, 'ref' => 3, 'createdAt' => 4, 'updatedAt' => 5, 'version' => 6, 'versionCreatedAt' => 7, 'versionCreatedBy' => 8, ),
     111:         BasePeer::TYPE_COLNAME => array (MessageVersionPeer::ID => 0, MessageVersionPeer::CODE => 1, MessageVersionPeer::SECURED => 2, MessageVersionPeer::REF => 3, MessageVersionPeer::CREATED_AT => 4, MessageVersionPeer::UPDATED_AT => 5, MessageVersionPeer::VERSION => 6, MessageVersionPeer::VERSION_CREATED_AT => 7, MessageVersionPeer::VERSION_CREATED_BY => 8, ),
     112:         BasePeer::TYPE_RAW_COLNAME => array ('ID' => 0, 'CODE' => 1, 'SECURED' => 2, 'REF' => 3, 'CREATED_AT' => 4, 'UPDATED_AT' => 5, 'VERSION' => 6, 'VERSION_CREATED_AT' => 7, 'VERSION_CREATED_BY' => 8, ),
     113:         BasePeer::TYPE_FIELDNAME => array ('id' => 0, 'code' => 1, 'secured' => 2, 'ref' => 3, 'created_at' => 4, 'updated_at' => 5, 'version' => 6, 'version_created_at' => 7, 'version_created_by' => 8, ),
     114:         BasePeer::TYPE_NUM => array (0, 1, 2, 3, 4, 5, 6, 7, 8, )
     115:     );
     116:
     117:     /**
     118:      * Translates a fieldname to another type
     119:      *
     120:      * @param      string $name field name
     121:      * @param      string $fromType One of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME
     122:      *                         BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM
     123:      * @param      string $toType   One of the class type constants
     124:      * @return string          translated name of the field.
     125:      * @throws PropelException - if the specified name could not be found in the fieldname mappings.
     126:      */
     127:     public static function translateFieldName($name, $fromType, $toType)
     128:     {
     129:         $toNames = MessageVersionPeer::getFieldNames($toType);
     130:         $key = isset(MessageVersionPeer::$fieldKeys[$fromType][$name]) ? MessageVersionPeer::$fieldKeys[$fromType][$name] : null;
     131:         if ($key === null) {
     132:             throw new PropelException("'$name' could not be found in the field names of type '$fromType'. These are: " . print_r(MessageVersionPeer::$fieldKeys[$fromType], true));
     133:         }
     134:
     135:         return $toNames[$key];
     136:     }
     137:
     138:     /**
     139:      * Returns an array of field names.
     140:      *
     141:      * @param      string $type The type of fieldnames to return:
     142:      *                      One of the class type constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME
     143:      *                      BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM
     144:      * @return array           A list of field names
     145:      * @throws PropelException - if the type is not valid.
     146:      */
     147:     public static function getFieldNames($type = BasePeer::TYPE_PHPNAME)
     148:     {
     149:         if (!array_key_exists($type, MessageVersionPeer::$fieldNames)) {
     150:             throw new PropelException('Method getFieldNames() expects the parameter $type to be one of the class constants BasePeer::TYPE_PHPNAME, BasePeer::TYPE_STUDLYPHPNAME, BasePeer::TYPE_COLNAME, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_NUM. ' . $type . ' was given.');
     151:         }
     152:
     153:         return MessageVersionPeer::$fieldNames[$type];
     154:     }
     155:
     156:     /**
     157:      * Convenience method which changes table.column to alias.column.
     158:      *
     159:      * Using this method you can maintain SQL abstraction while using column aliases.
     160:      * <code>
     161:      *      $c->addAlias("alias1", TablePeer::TABLE_NAME);
     162:      *      $c->addJoin(TablePeer::alias("alias1", TablePeer::PRIMARY_KEY_COLUMN), TablePeer::PRIMARY_KEY_COLUMN);
     163:      * </code>
     164:      * @param      string $alias The alias for the current table.
     165:      * @param      string $column The column name for current table. (i.e. MessageVersionPeer::COLUMN_NAME).
     166:      * @return string
     167:      */
     168:     public static function alias($alias, $column)
     169:     {
     170:         return str_replace(MessageVersionPeer::TABLE_NAME.'.', $alias.'.', $column);
     171:     }
     172:
     173:     /**
     174:      * Add all the columns needed to create a new object.
     175:      *
     176:      * Note: any columns that were marked with lazyLoad="true" in the
     177:      * XML schema will not be added to the select list and only loaded
     178:      * on demand.
     179:      *
     180:      * @param      Criteria $criteria object containing the columns to add.
     181:      * @param      string   $alias    optional table alias
     182:      * @throws PropelException Any exceptions caught during processing will be
     183:      *       rethrown wrapped into a PropelException.
     184:      */
     185:     public static function addSelectColumns(Criteria $criteria, $alias = null)
     186:     {
     187:         if (null === $alias) {
     188:             $criteria->addSelectColumn(MessageVersionPeer::ID);
     189:             $criteria->addSelectColumn(MessageVersionPeer::CODE);
     190:             $criteria->addSelectColumn(MessageVersionPeer::SECURED);
     191:             $criteria->addSelectColumn(MessageVersionPeer::REF);
     192:             $criteria->addSelectColumn(MessageVersionPeer::CREATED_AT);
     193:             $criteria->addSelectColumn(MessageVersionPeer::UPDATED_AT);
     194:             $criteria->addSelectColumn(MessageVersionPeer::VERSION);
     195:             $criteria->addSelectColumn(MessageVersionPeer::VERSION_CREATED_AT);
     196:             $criteria->addSelectColumn(MessageVersionPeer::VERSION_CREATED_BY);
     197:         } else {
     198:             $criteria->addSelectColumn($alias . '.id');
     199:             $criteria->addSelectColumn($alias . '.code');
     200:             $criteria->addSelectColumn($alias . '.secured');
     201:             $criteria->addSelectColumn($alias . '.ref');
     202:             $criteria->addSelectColumn($alias . '.created_at');
     203:             $criteria->addSelectColumn($alias . '.updated_at');
     204:             $criteria->addSelectColumn($alias . '.version');
     205:             $criteria->addSelectColumn($alias . '.version_created_at');
     206:             $criteria->addSelectColumn($alias . '.version_created_by');
     207:         }
     208:     }
     209:
     210:     /**
     211:      * Returns the number of rows matching criteria.
     212:      *
     213:      * @param      Criteria $criteria
     214:      * @param      boolean $distinct Whether to select only distinct columns; deprecated: use Criteria->setDistinct() instead.
     215:      * @param      PropelPDO $con
     216:      * @return int Number of matching rows.
     217:      */
     218:     public static function doCount(Criteria $criteria, $distinct = false, PropelPDO $con = null)
     219:     {
     220:         // we may modify criteria, so copy it first
     221:         $criteria = clone $criteria;
     222:
     223:         // We need to set the primary table name, since in the case that there are no WHERE columns
     224:         // it will be impossible for the BasePeer::createSelectSql() method to determine which
     225:         // tables go into the FROM clause.
     226:         $criteria->setPrimaryTableName(MessageVersionPeer::TABLE_NAME);
     227:
     228:         if ($distinct && !in_array(Criteria::DISTINCT, $criteria->getSelectModifiers())) {
     229:             $criteria->setDistinct();
     230:         }
     231:
     232:         if (!$criteria->hasSelectClause()) {
     233:             MessageVersionPeer::addSelectColumns($criteria);
     234:         }
     235:
     236:         $criteria->clearOrderByColumns(); // ORDER BY won't ever affect the count
     237:         $criteria->setDbName(MessageVersionPeer::DATABASE_NAME); // Set the correct dbName
     238:
     239:         if ($con === null) {
     240:             $con = Propel::getConnection(MessageVersionPeer::DATABASE_NAME, Propel::CONNECTION_READ);
     241:         }
     242:         // BasePeer returns a PDOStatement
     243:         $stmt = BasePeer::doCount($criteria, $con);
     244:
     245:         if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
     246:             $count = (int) $row[0];
     247:         } else {
     248:             $count = 0; // no rows returned; we infer that means 0 matches.
     249:         }
     250:         $stmt->closeCursor();
     251:
     252:         return $count;
     253:     }
     254:     /**
     255:      * Selects one object from the DB.
     256:      *
     257:      * @param      Criteria $criteria object used to create the SELECT statement.
     258:      * @param      PropelPDO $con
     259:      * @return                 MessageVersion
     260:      * @throws PropelException Any exceptions caught during processing will be
     261:      *       rethrown wrapped into a PropelException.
     262:      */
     263:     public static function doSelectOne(Criteria $criteria, PropelPDO $con = null)
     264:     {
     265:         $critcopy = clone $criteria;
     266:         $critcopy->setLimit(1);
     267:         $objects = MessageVersionPeer::doSelect($critcopy, $con);
     268:         if ($objects) {
     269:             return $objects[0];
     270:         }
     271:
     272:         return null;
     273:     }
     274:     /**
     275:      * Selects several row from the DB.
     276:      *
     277:      * @param      Criteria $criteria The Criteria object used to build the SELECT statement.
     278:      * @param      PropelPDO $con
     279:      * @return array           Array of selected Objects
     280:      * @throws PropelException Any exceptions caught during processing will be
     281:      *       rethrown wrapped into a PropelException.
     282:      */
     283:     public static function doSelect(Criteria $criteria, PropelPDO $con = null)
     284:     {
     285:         return MessageVersionPeer::populateObjects(MessageVersionPeer::doSelectStmt($criteria, $con));
     286:     }
     287:     /**
     288:      * Prepares the Criteria object and uses the parent doSelect() method to execute a PDOStatement.
     289:      *
     290:      * Use this method directly if you want to work with an executed statement directly (for example
     291:      * to perform your own object hydration).
     292:      *
     293:      * @param      Criteria $criteria The Criteria object used to build the SELECT statement.
     294:      * @param      PropelPDO $con The connection to use
     295:      * @throws PropelException Any exceptions caught during processing will be
     296:      *       rethrown wrapped into a PropelException.
     297:      * @return PDOStatement The executed PDOStatement object.
     298:      * @see        BasePeer::doSelect()
     299:      */
     300:     public static function doSelectStmt(Criteria $criteria, PropelPDO $con = null)
     301:     {
     302:         if ($con === null) {
     303:             $con = Propel::getConnection(MessageVersionPeer::DATABASE_NAME, Propel::CONNECTION_READ);
     304:         }
     305:
     306:         if (!$criteria->hasSelectClause()) {
     307:             $criteria = clone $criteria;
     308:             MessageVersionPeer::addSelectColumns($criteria);
     309:         }
     310:
     311:         // Set the correct dbName
     312:         $criteria->setDbName(MessageVersionPeer::DATABASE_NAME);
     313:
     314:         // BasePeer returns a PDOStatement
     315:         return BasePeer::doSelect($criteria, $con);
     316:     }
     317:     /**
     318:      * Adds an object to the instance pool.
     319:      *
     320:      * Propel keeps cached copies of objects in an instance pool when they are retrieved
     321:      * from the database.  In some cases -- especially when you override doSelect*()
     322:      * methods in your stub classes -- you may need to explicitly add objects
     323:      * to the cache in order to ensure that the same objects are always returned by doSelect*()
     324:      * and retrieveByPK*() calls.
     325:      *
     326:      * @param      MessageVersion $obj A MessageVersion object.
     327:      * @param      string $key (optional) key to use for instance map (for performance boost if key was already calculated externally).
     328:      */
     329:     public static function addInstanceToPool($obj, $key = null)
     330:     {
     331:         if (Propel::isInstancePoolingEnabled()) {
     332:             if ($key === null) {
     333:                 $key = serialize(array((string) $obj->getId(), (string) $obj->getVersion()));
     334:             } // if key === null
     335:             MessageVersionPeer::$instances[$key] = $obj;
     336:         }
     337:     }
     338:
     339:     /**
     340:      * Removes an object from the instance pool.
     341:      *
     342:      * Propel keeps cached copies of objects in an instance pool when they are retrieved
     343:      * from the database.  In some cases -- especially when you override doDelete
     344:      * methods in your stub classes -- you may need to explicitly remove objects
     345:      * from the cache in order to prevent returning objects that no longer exist.
     346:      *
     347:      * @param      mixed $value A MessageVersion object or a primary key value.
     348:      *
     349:      * @return void
     350:      * @throws PropelException - if the value is invalid.
     351:      */
     352:     public static function removeInstanceFromPool($value)
     353:     {
     354:         if (Propel::isInstancePoolingEnabled() && $value !== null) {
     355:             if (is_object($value) && $value instanceof MessageVersion) {
     356:                 $key = serialize(array((string) $value->getId(), (string) $value->getVersion()));
     357:             } elseif (is_array($value) && count($value) === 2) {
     358:                 // assume we've been passed a primary key
     359:                 $key = serialize(array((string) $value[0], (string) $value[1]));
     360:             } else {
     361:                 $e = new PropelException("Invalid value passed to removeInstanceFromPool().  Expected primary key or MessageVersion object; got " . (is_object($value) ? get_class($value) . ' object.' : var_export($value,true)));
     362:                 throw $e;
     363:             }
     364:
     365:             unset(MessageVersionPeer::$instances[$key]);
     366:         }
     367:     } // removeInstanceFromPool()
     368:
     369:     /**
     370:      * 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.
     371:      *
     372:      * For tables with a single-column primary key, that simple pkey value will be returned.  For tables with
     373:      * a multi-column primary key, a serialize()d version of the primary key will be returned.
     374:      *
     375:      * @param      string $key The key (@see getPrimaryKeyHash()) for this instance.
     376:      * @return   MessageVersion Found object or null if 1) no instance exists for specified key or 2) instance pooling has been disabled.
     377:      * @see        getPrimaryKeyHash()
     378:      */
     379:     public static function getInstanceFromPool($key)
     380:     {
     381:         if (Propel::isInstancePoolingEnabled()) {
     382:             if (isset(MessageVersionPeer::$instances[$key])) {
     383:                 return MessageVersionPeer::$instances[$key];
     384:             }
     385:         }
     386:
     387:         return null; // just to be explicit
     388:     }
     389:
     390:     /**
     391:      * Clear the instance pool.
     392:      *
     393:      * @return void
     394:      */
     395:     public static function clearInstancePool($and_clear_all_references = false)
     396:     {
     397:       if ($and_clear_all_references)
     398:       {
     399:         foreach (MessageVersionPeer::$instances as $instance)
     400:         {
     401:           $instance->clearAllReferences(true);
     402:         }
     403:       }
     404:         MessageVersionPeer::$instances = array();
     405:     }
     406:
     407:     /**
     408:      * Method to invalidate the instance pool of all tables related to message_version
     409:      * by a foreign key with ON DELETE CASCADE
     410:      */
     411:     public static function clearRelatedInstancePool()
     412:     {
     413:     }
     414:
     415:     /**
     416:      * 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.
     417:      *
     418:      * For tables with a single-column primary key, that simple pkey value will be returned.  For tables with
     419:      * a multi-column primary key, a serialize()d version of the primary key will be returned.
     420:      *
     421:      * @param      array $row PropelPDO resultset row.
     422:      * @param      int $startcol The 0-based offset for reading from the resultset row.
     423:      * @return string A string version of PK or null if the components of primary key in result array are all null.
     424:      */
     425:     public static function getPrimaryKeyHashFromRow($row, $startcol = 0)
     426:     {
     427:         // If the PK cannot be derived from the row, return null.
     428:         if ($row[$startcol] === null && $row[$startcol + 6] === null) {
     429:             return null;
     430:         }
     431:
     432:         return serialize(array((string) $row[$startcol], (string) $row[$startcol + 6]));
     433:     }
     434:
     435:     /**
     436:      * Retrieves the primary key from the DB resultset row
     437:      * For tables with a single-column primary key, that simple pkey value will be returned.  For tables with
     438:      * a multi-column primary key, an array of the primary key columns will be returned.
     439:      *
     440:      * @param      array $row PropelPDO resultset row.
     441:      * @param      int $startcol The 0-based offset for reading from the resultset row.
     442:      * @return mixed The primary key of the row
     443:      */
     444:     public static function getPrimaryKeyFromRow($row, $startcol = 0)
     445:     {
     446:
     447:         return array((int) $row[$startcol], (int) $row[$startcol + 6]);
     448:     }
     449:
     450:     /**
     451:      * The returned array will contain objects of the default type or
     452:      * objects that inherit from the default.
     453:      *
     454:      * @throws PropelException Any exceptions caught during processing will be
     455:      *       rethrown wrapped into a PropelException.
     456:      */
     457:     public static function populateObjects(PDOStatement $stmt)
     458:     {
     459:         $results = array();
     460:
     461:         // set the class once to avoid overhead in the loop
     462:         $cls = MessageVersionPeer::getOMClass();
     463:         // populate the object(s)
     464:         while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
     465:             $key = MessageVersionPeer::getPrimaryKeyHashFromRow($row, 0);
     466:             if (null !== ($obj = MessageVersionPeer::getInstanceFromPool($key))) {
     467:                 // We no longer rehydrate the object, since this can cause data loss.
     468:                 // See http://www.propelorm.org/ticket/509
     469:                 // $obj->hydrate($row, 0, true); // rehydrate
     470:                 $results[] = $obj;
     471:             } else {
     472:                 $obj = new $cls();
     473:                 $obj->hydrate($row);
     474:                 $results[] = $obj;
     475:                 MessageVersionPeer::addInstanceToPool($obj, $key);
     476:             } // if key exists
     477:         }
     478:         $stmt->closeCursor();
     479:
     480:         return $results;
     481:     }
     482:     /**
     483:      * Populates an object of the default type or an object that inherit from the default.
     484:      *
     485:      * @param      array $row PropelPDO resultset row.
     486:      * @param      int $startcol The 0-based offset for reading from the resultset row.
     487:      * @throws PropelException Any exceptions caught during processing will be
     488:      *       rethrown wrapped into a PropelException.
     489:      * @return array (MessageVersion object, last column rank)
     490:      */
     491:     public static function populateObject($row, $startcol = 0)
     492:     {
     493:         $key = MessageVersionPeer::getPrimaryKeyHashFromRow($row, $startcol);
     494:         if (null !== ($obj = MessageVersionPeer::getInstanceFromPool($key))) {
     495:             // We no longer rehydrate the object, since this can cause data loss.
     496:             // See http://www.propelorm.org/ticket/509
     497:             // $obj->hydrate($row, $startcol, true); // rehydrate
     498:             $col = $startcol + MessageVersionPeer::NUM_HYDRATE_COLUMNS;
     499:         } else {
     500:             $cls = MessageVersionPeer::OM_CLASS;
     501:             $obj = new $cls();
     502:             $col = $obj->hydrate($row, $startcol);
     503:             MessageVersionPeer::addInstanceToPool($obj, $key);
     504:         }
     505:
     506:         return array($obj, $col);
     507:     }
     508:
     509:
     510:     /**
     511:      * Returns the number of rows matching criteria, joining the related Message table
     512:      *
     513:      * @param      Criteria $criteria
     514:      * @param      boolean $distinct Whether to select only distinct columns; deprecated: use Criteria->setDistinct() instead.
     515:      * @param      PropelPDO $con
     516:      * @param      String    $join_behavior the type of joins to use, defaults to Criteria::LEFT_JOIN
     517:      * @return int Number of matching rows.
     518:      */
     519:     public static function doCountJoinMessage(Criteria $criteria, $distinct = false, PropelPDO $con = null, $join_behavior = Criteria::LEFT_JOIN)
     520:     {
     521:         // we're going to modify criteria, so copy it first
     522:         $criteria = clone $criteria;
     523:
     524:         // We need to set the primary table name, since in the case that there are no WHERE columns
     525:         // it will be impossible for the BasePeer::createSelectSql() method to determine which
     526:         // tables go into the FROM clause.
     527:         $criteria->setPrimaryTableName(MessageVersionPeer::TABLE_NAME);
     528:
     529:         if ($distinct && !in_array(Criteria::DISTINCT, $criteria->getSelectModifiers())) {
     530:             $criteria->setDistinct();
     531:         }
     532:
     533:         if (!$criteria->hasSelectClause()) {
     534:             MessageVersionPeer::addSelectColumns($criteria);
     535:         }
     536:
     537:         $criteria->clearOrderByColumns(); // ORDER BY won't ever affect the count
     538:
     539:         // Set the correct dbName
     540:         $criteria->setDbName(MessageVersionPeer::DATABASE_NAME);
     541:
     542:         if ($con === null) {
     543:             $con = Propel::getConnection(MessageVersionPeer::DATABASE_NAME, Propel::CONNECTION_READ);
     544:         }
     545:
     546:         $criteria->addJoin(MessageVersionPeer::ID, MessagePeer::ID, $join_behavior);
     547:
     548:         $stmt = BasePeer::doCount($criteria, $con);
     549:
     550:         if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
     551:             $count = (int) $row[0];
     552:         } else {
     553:             $count = 0; // no rows returned; we infer that means 0 matches.
     554:         }
     555:         $stmt->closeCursor();
     556:
     557:         return $count;
     558:     }
     559:
     560:
     561:     /**
     562:      * Selects a collection of MessageVersion objects pre-filled with their Message objects.
     563:      * @param      Criteria  $criteria
     564:      * @param      PropelPDO $con
     565:      * @param      String    $join_behavior the type of joins to use, defaults to Criteria::LEFT_JOIN
     566:      * @return array           Array of MessageVersion objects.
     567:      * @throws PropelException Any exceptions caught during processing will be
     568:      *       rethrown wrapped into a PropelException.
     569:      */
     570:     public static function doSelectJoinMessage(Criteria $criteria, $con = null, $join_behavior = Criteria::LEFT_JOIN)
     571:     {
     572:         $criteria = clone $criteria;
     573:
     574:         // Set the correct dbName if it has not been overridden
     575:         if ($criteria->getDbName() == Propel::getDefaultDB()) {
     576:             $criteria->setDbName(MessageVersionPeer::DATABASE_NAME);
     577:         }
     578:
     579:         MessageVersionPeer::addSelectColumns($criteria);
     580:         $startcol = MessageVersionPeer::NUM_HYDRATE_COLUMNS;
     581:         MessagePeer::addSelectColumns($criteria);
     582:
     583:         $criteria->addJoin(MessageVersionPeer::ID, MessagePeer::ID, $join_behavior);
     584:
     585:         $stmt = BasePeer::doSelect($criteria, $con);
     586:         $results = array();
     587:
     588:         while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
     589:             $key1 = MessageVersionPeer::getPrimaryKeyHashFromRow($row, 0);
     590:             if (null !== ($obj1 = MessageVersionPeer::getInstanceFromPool($key1))) {
     591:                 // We no longer rehydrate the object, since this can cause data loss.
     592:                 // See http://www.propelorm.org/ticket/509
     593:                 // $obj1->hydrate($row, 0, true); // rehydrate
     594:             } else {
     595:
     596:                 $cls = MessageVersionPeer::getOMClass();
     597:
     598:                 $obj1 = new $cls();
     599:                 $obj1->hydrate($row);
     600:                 MessageVersionPeer::addInstanceToPool($obj1, $key1);
     601:             } // if $obj1 already loaded
     602:
     603:             $key2 = MessagePeer::getPrimaryKeyHashFromRow($row, $startcol);
     604:             if ($key2 !== null) {
     605:                 $obj2 = MessagePeer::getInstanceFromPool($key2);
     606:                 if (!$obj2) {
     607:
     608:                     $cls = MessagePeer::getOMClass();
     609:
     610:                     $obj2 = new $cls();
     611:                     $obj2->hydrate($row, $startcol);
     612:                     MessagePeer::addInstanceToPool($obj2, $key2);
     613:                 } // if obj2 already loaded
     614:
     615:                 // Add the $obj1 (MessageVersion) to $obj2 (Message)
     616:                 $obj2->addMessageVersion($obj1);
     617:
     618:             } // if joined row was not null
     619:
     620:             $results[] = $obj1;
     621:         }
     622:         $stmt->closeCursor();
     623:
     624:         return $results;
     625:     }
     626:
     627:
     628:     /**
     629:      * Returns the number of rows matching criteria, joining all related tables
     630:      *
     631:      * @param      Criteria $criteria
     632:      * @param      boolean $distinct Whether to select only distinct columns; deprecated: use Criteria->setDistinct() instead.
     633:      * @param      PropelPDO $con
     634:      * @param      String    $join_behavior the type of joins to use, defaults to Criteria::LEFT_JOIN
     635:      * @return int Number of matching rows.
     636:      */
     637:     public static function doCountJoinAll(Criteria $criteria, $distinct = false, PropelPDO $con = null, $join_behavior = Criteria::LEFT_JOIN)
     638:     {
     639:         // we're going to modify criteria, so copy it first
     640:         $criteria = clone $criteria;
     641:
     642:         // We need to set the primary table name, since in the case that there are no WHERE columns
     643:         // it will be impossible for the BasePeer::createSelectSql() method to determine which
     644:         // tables go into the FROM clause.
     645:         $criteria->setPrimaryTableName(MessageVersionPeer::TABLE_NAME);
     646:
     647:         if ($distinct && !in_array(Criteria::DISTINCT, $criteria->getSelectModifiers())) {
     648:             $criteria->setDistinct();
     649:         }
     650:
     651:         if (!$criteria->hasSelectClause()) {
     652:             MessageVersionPeer::addSelectColumns($criteria);
     653:         }
     654:
     655:         $criteria->clearOrderByColumns(); // ORDER BY won't ever affect the count
     656:
     657:         // Set the correct dbName
     658:         $criteria->setDbName(MessageVersionPeer::DATABASE_NAME);
     659:
     660:         if ($con === null) {
     661:             $con = Propel::getConnection(MessageVersionPeer::DATABASE_NAME, Propel::CONNECTION_READ);
     662:         }
     663:
     664:         $criteria->addJoin(MessageVersionPeer::ID, MessagePeer::ID, $join_behavior);
     665:
     666:         $stmt = BasePeer::doCount($criteria, $con);
     667:
     668:         if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
     669:             $count = (int) $row[0];
     670:         } else {
     671:             $count = 0; // no rows returned; we infer that means 0 matches.
     672:         }
     673:         $stmt->closeCursor();
     674:
     675:         return $count;
     676:     }
     677:
     678:     /**
     679:      * Selects a collection of MessageVersion objects pre-filled with all related objects.
     680:      *
     681:      * @param      Criteria  $criteria
     682:      * @param      PropelPDO $con
     683:      * @param      String    $join_behavior the type of joins to use, defaults to Criteria::LEFT_JOIN
     684:      * @return array           Array of MessageVersion objects.
     685:      * @throws PropelException Any exceptions caught during processing will be
     686:      *       rethrown wrapped into a PropelException.
     687:      */
     688:     public static function doSelectJoinAll(Criteria $criteria, $con = null, $join_behavior = Criteria::LEFT_JOIN)
     689:     {
     690:         $criteria = clone $criteria;
     691:
     692:         // Set the correct dbName if it has not been overridden
     693:         if ($criteria->getDbName() == Propel::getDefaultDB()) {
     694:             $criteria->setDbName(MessageVersionPeer::DATABASE_NAME);
     695:         }
     696:
     697:         MessageVersionPeer::addSelectColumns($criteria);
     698:         $startcol2 = MessageVersionPeer::NUM_HYDRATE_COLUMNS;
     699:
     700:         MessagePeer::addSelectColumns($criteria);
     701:         $startcol3 = $startcol2 + MessagePeer::NUM_HYDRATE_COLUMNS;
     702:
     703:         $criteria->addJoin(MessageVersionPeer::ID, MessagePeer::ID, $join_behavior);
     704:
     705:         $stmt = BasePeer::doSelect($criteria, $con);
     706:         $results = array();
     707:
     708:         while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
     709:             $key1 = MessageVersionPeer::getPrimaryKeyHashFromRow($row, 0);
     710:             if (null !== ($obj1 = MessageVersionPeer::getInstanceFromPool($key1))) {
     711:                 // We no longer rehydrate the object, since this can cause data loss.
     712:                 // See http://www.propelorm.org/ticket/509
     713:                 // $obj1->hydrate($row, 0, true); // rehydrate
     714:             } else {
     715:                 $cls = MessageVersionPeer::getOMClass();
     716:
     717:                 $obj1 = new $cls();
     718:                 $obj1->hydrate($row);
     719:                 MessageVersionPeer::addInstanceToPool($obj1, $key1);
     720:             } // if obj1 already loaded
     721:
     722:             // Add objects for joined Message rows
     723:
     724:             $key2 = MessagePeer::getPrimaryKeyHashFromRow($row, $startcol2);
     725:             if ($key2 !== null) {
     726:                 $obj2 = MessagePeer::getInstanceFromPool($key2);
     727:                 if (!$obj2) {
     728:
     729:                     $cls = MessagePeer::getOMClass();
     730:
     731:                     $obj2 = new $cls();
     732:                     $obj2->hydrate($row, $startcol2);
     733:                     MessagePeer::addInstanceToPool($obj2, $key2);
     734:                 } // if obj2 loaded
     735:
     736:                 // Add the $obj1 (MessageVersion) to the collection in $obj2 (Message)
     737:                 $obj2->addMessageVersion($obj1);
     738:             } // if joined row not null
     739:
     740:             $results[] = $obj1;
     741:         }
     742:         $stmt->closeCursor();
     743:
     744:         return $results;
     745:     }
     746:
     747:     /**
     748:      * Returns the TableMap related to this peer.
     749:      * This method is not needed for general use but a specific application could have a need.
     750:      * @return TableMap
     751:      * @throws PropelException Any exceptions caught during processing will be
     752:      *       rethrown wrapped into a PropelException.
     753:      */
     754:     public static function getTableMap()
     755:     {
     756:         return Propel::getDatabaseMap(MessageVersionPeer::DATABASE_NAME)->getTable(MessageVersionPeer::TABLE_NAME);
     757:     }
     758:
     759:     /**
     760:      * Add a TableMap instance to the database for this peer class.
     761:      */
     762:     public static function buildTableMap()
     763:     {
     764:       $dbMap = Propel::getDatabaseMap(BaseMessageVersionPeer::DATABASE_NAME);
     765:       if (!$dbMap->hasTable(BaseMessageVersionPeer::TABLE_NAME)) {
     766:         $dbMap->addTableObject(new MessageVersionTableMap());
     767:       }
     768:     }
     769:
     770:     /**
     771:      * The class that the Peer will make instances of.
     772:      *
     773:      *
     774:      * @return string ClassName
     775:      */
     776:     public static function getOMClass($row = 0, $colnum = 0)
     777:     {
     778:         return MessageVersionPeer::OM_CLASS;
     779:     }
     780:
     781:     /**
     782:      * Performs an INSERT on the database, given a MessageVersion or Criteria object.
     783:      *
     784:      * @param      mixed $values Criteria or MessageVersion object containing data that is used to create the INSERT statement.
     785:      * @param      PropelPDO $con the PropelPDO connection to use
     786:      * @return mixed           The new primary key.
     787:      * @throws PropelException Any exceptions caught during processing will be
     788:      *       rethrown wrapped into a PropelException.
     789:      */
     790:     public static function doInsert($values, PropelPDO $con = null)
     791:     {
     792:         if ($con === null) {
     793:             $con = Propel::getConnection(MessageVersionPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
     794:         }
     795:
     796:         if ($values instanceof Criteria) {
     797:             $criteria = clone $values; // rename for clarity
     798:         } else {
     799:             $criteria = $values->buildCriteria(); // build Criteria from MessageVersion object
     800:         }
     801:
     802:
     803:         // Set the correct dbName
     804:         $criteria->setDbName(MessageVersionPeer::DATABASE_NAME);
     805:
     806:         try {
     807:             // use transaction because $criteria could contain info
     808:             // for more than one table (I guess, conceivably)
     809:             $con->beginTransaction();
     810:             $pk = BasePeer::doInsert($criteria, $con);
     811:             $con->commit();
     812:         } catch (PropelException $e) {
     813:             $con->rollBack();
     814:             throw $e;
     815:         }
     816:
     817:         return $pk;
     818:     }
     819:
     820:     /**
     821:      * Performs an UPDATE on the database, given a MessageVersion or Criteria object.
     822:      *
     823:      * @param      mixed $values Criteria or MessageVersion object containing data that is used to create the UPDATE statement.
     824:      * @param      PropelPDO $con The connection to use (specify PropelPDO connection object to exert more control over transactions).
     825:      * @return int             The number of affected rows (if supported by underlying database driver).
     826:      * @throws PropelException Any exceptions caught during processing will be
     827:      *       rethrown wrapped into a PropelException.
     828:      */
     829:     public static function doUpdate($values, PropelPDO $con = null)
     830:     {
     831:         if ($con === null) {
     832:             $con = Propel::getConnection(MessageVersionPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
     833:         }
     834:
     835:         $selectCriteria = new Criteria(MessageVersionPeer::DATABASE_NAME);
     836:
     837:         if ($values instanceof Criteria) {
     838:             $criteria = clone $values; // rename for clarity
     839:
     840:             $comparison = $criteria->getComparison(MessageVersionPeer::ID);
     841:             $value = $criteria->remove(MessageVersionPeer::ID);
     842:             if ($value) {
     843:                 $selectCriteria->add(MessageVersionPeer::ID, $value, $comparison);
     844:             } else {
     845:                 $selectCriteria->setPrimaryTableName(MessageVersionPeer::TABLE_NAME);
     846:             }
     847:
     848:             $comparison = $criteria->getComparison(MessageVersionPeer::VERSION);
     849:             $value = $criteria->remove(MessageVersionPeer::VERSION);
     850:             if ($value) {
     851:                 $selectCriteria->add(MessageVersionPeer::VERSION, $value, $comparison);
     852:             } else {
     853:                 $selectCriteria->setPrimaryTableName(MessageVersionPeer::TABLE_NAME);
     854:             }
     855:
     856:         } else { // $values is MessageVersion object
     857:             $criteria = $values->buildCriteria(); // gets full criteria
     858:             $selectCriteria = $values->buildPkeyCriteria(); // gets criteria w/ primary key(s)
     859:         }
     860:
     861:         // set the correct dbName
     862:         $criteria->setDbName(MessageVersionPeer::DATABASE_NAME);
     863:
     864:         return BasePeer::doUpdate($selectCriteria, $criteria, $con);
     865:     }
     866:
     867:     /**
     868:      * Deletes all rows from the message_version table.
     869:      *
     870:      * @param      PropelPDO $con the connection to use
     871:      * @return int             The number of affected rows (if supported by underlying database driver).
     872:      * @throws PropelException
     873:      */
     874:     public static function doDeleteAll(PropelPDO $con = null)
     875:     {
     876:         if ($con === null) {
     877:             $con = Propel::getConnection(MessageVersionPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
     878:         }
     879:         $affectedRows = 0; // initialize var to track total num of affected rows
     880:         try {
     881:             // use transaction because $criteria could contain info
     882:             // for more than one table or we could emulating ON DELETE CASCADE, etc.
     883:             $con->beginTransaction();
     884:             $affectedRows += BasePeer::doDeleteAll(MessageVersionPeer::TABLE_NAME, $con, MessageVersionPeer::DATABASE_NAME);
     885:             // Because this db requires some delete cascade/set null emulation, we have to
     886:             // clear the cached instance *after* the emulation has happened (since
     887:             // instances get re-added by the select statement contained therein).
     888:             MessageVersionPeer::clearInstancePool();
     889:             MessageVersionPeer::clearRelatedInstancePool();
     890:             $con->commit();
     891:
     892:             return $affectedRows;
     893:         } catch (PropelException $e) {
     894:             $con->rollBack();
     895:             throw $e;
     896:         }
     897:     }
     898:
     899:     /**
     900:      * Performs a DELETE on the database, given a MessageVersion or Criteria object OR a primary key value.
     901:      *
     902:      * @param      mixed $values Criteria or MessageVersion object or primary key or array of primary keys
     903:      *              which is used to create the DELETE statement
     904:      * @param      PropelPDO $con the connection to use
     905:      * @return int The number of affected rows (if supported by underlying database driver).  This includes CASCADE-related rows
     906:      *              if supported by native driver or if emulated using Propel.
     907:      * @throws PropelException Any exceptions caught during processing will be
     908:      *       rethrown wrapped into a PropelException.
     909:      */
     910:      public static function doDelete($values, PropelPDO $con = null)
     911:      {
     912:         if ($con === null) {
     913:             $con = Propel::getConnection(MessageVersionPeer::DATABASE_NAME, Propel::CONNECTION_WRITE);
     914:         }
     915:
     916:         if ($values instanceof Criteria) {
     917:             // invalidate the cache for all objects of this type, since we have no
     918:             // way of knowing (without running a query) what objects should be invalidated
     919:             // from the cache based on this Criteria.
     920:             MessageVersionPeer::clearInstancePool();
     921:             // rename for clarity
     922:             $criteria = clone $values;
     923:         } elseif ($values instanceof MessageVersion) { // it's a model object
     924:             // invalidate the cache for this single object
     925:             MessageVersionPeer::removeInstanceFromPool($values);
     926:             // create criteria based on pk values
     927:             $criteria = $values->buildPkeyCriteria();
     928:         } else { // it's a primary key, or an array of pks
     929:             $criteria = new Criteria(MessageVersionPeer::DATABASE_NAME);
     930:             // primary key is composite; we therefore, expect
     931:             // the primary key passed to be an array of pkey values
     932:             if (count($values) == count($values, COUNT_RECURSIVE)) {
     933:                 // array is not multi-dimensional
     934:                 $values = array($values);
     935:             }
     936:             foreach ($values as $value) {
     937:                 $criterion = $criteria->getNewCriterion(MessageVersionPeer::ID, $value[0]);
     938:                 $criterion->addAnd($criteria->getNewCriterion(MessageVersionPeer::VERSION, $value[1]));
     939:                 $criteria->addOr($criterion);
     940:                 // we can invalidate the cache for this single PK
     941:                 MessageVersionPeer::removeInstanceFromPool($value);
     942:             }
     943:         }
     944:
     945:         // Set the correct dbName
     946:         $criteria->setDbName(MessageVersionPeer::DATABASE_NAME);
     947:
     948:         $affectedRows = 0; // initialize var to track total num of affected rows
     949:
     950:         try {
     951:             // use transaction because $criteria could contain info
     952:             // for more than one table or we could emulating ON DELETE CASCADE, etc.
     953:             $con->beginTransaction();
     954:
     955:             $affectedRows += BasePeer::doDelete($criteria, $con);
     956:             MessageVersionPeer::clearRelatedInstancePool();
     957:             $con->commit();
     958:
     959:             return $affectedRows;
     960:         } catch (PropelException $e) {
     961:             $con->rollBack();
     962:             throw $e;
     963:         }
     964:     }
     965:
     966:     /**
     967:      * Validates all modified columns of given MessageVersion object.
     968:      * If parameter $columns is either a single column name or an array of column names
     969:      * than only those columns are validated.
     970:      *
     971:      * NOTICE: This does not apply to primary or foreign keys for now.
     972:      *
     973:      * @param      MessageVersion $obj The object to validate.
     974:      * @param      mixed $cols Column name or array of column names.
     975:      *
     976:      * @return mixed TRUE if all columns are valid or the error message of the first invalid column.
     977:      */
     978:     public static function doValidate($obj, $cols = null)
     979:     {
     980:         $columns = array();
     981:
     982:         if ($cols) {
     983:             $dbMap = Propel::getDatabaseMap(MessageVersionPeer::DATABASE_NAME);
     984:             $tableMap = $dbMap->getTable(MessageVersionPeer::TABLE_NAME);
     985:
     986:             if (! is_array($cols)) {
     987:                 $cols = array($cols);
     988:             }
     989:
     990:             foreach ($cols as $colName) {
     991:                 if ($tableMap->hasColumn($colName)) {
     992:                     $get = 'get' . $tableMap->getColumn($colName)->getPhpName();
     993:                     $columns[$colName] = $obj->$get();
     994:                 }
     995:             }
     996:         } else {
     997:
     998:         }
     999:
    1000:         return BasePeer::doValidate(MessageVersionPeer::DATABASE_NAME, MessageVersionPeer::TABLE_NAME, $columns);
    1001:     }
    1002:
    1003:     /**
    1004:      * Retrieve object using using composite pkey values.
    1005:      * @param   int $id
    1006:      * @param   int $version
    1007:      * @param      PropelPDO $con
    1008:      * @return   MessageVersion
    1009:      */
    1010:     public static function retrieveByPK($id, $version, PropelPDO $con = null) {
    1011:         $_instancePoolKey = serialize(array((string) $id, (string) $version));
    1012:          if (null !== ($obj = MessageVersionPeer::getInstanceFromPool($_instancePoolKey))) {
    1013:              return $obj;
    1014:         }
    1015:
    1016:         if ($con === null) {
    1017:             $con = Propel::getConnection(MessageVersionPeer::DATABASE_NAME, Propel::CONNECTION_READ);
    1018:         }
    1019:         $criteria = new Criteria(MessageVersionPeer::DATABASE_NAME);
    1020:         $criteria->add(MessageVersionPeer::ID, $id);
    1021:         $criteria->add(MessageVersionPeer::VERSION, $version);
    1022:         $v = MessageVersionPeer::doSelect($criteria, $con);
    1023:
    1024:         return !empty($v) ? $v[0] : null;
    1025:     }
    1026: } // BaseMessageVersionPeer
    1027:
    1028: // This is the static code needed to register the TableMap for this table with the main Propel class.
    1029: //
    1030: BaseMessageVersionPeer::buildTableMap();
    1031:
    1032: