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