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

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