lib-model-om
[ class tree: lib-model-om ] [ index: lib-model-om ] [ all elements ]

Source for file BaseEtvaPhysicalvolumePeer.php

Documentation is available at BaseEtvaPhysicalvolumePeer.php

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

Documentation generated on Fri, 19 Jun 2009 10:47:43 +0100 by phpDocumentor 1.4.2