2015-03-02 21:57:49 +01:00
< ? php
namespace Trinity\Bundle\MediaBundle\Model\om ;
use \BasePeer ;
use \Criteria ;
use \PDO ;
use \PDOStatement ;
use \Propel ;
use \PropelException ;
use \PropelPDO ;
2015-11-25 18:28:10 +01:00
use Trinity\Bundle\MediaBundle\Model\MediaPeer ;
2015-03-02 21:57:49 +01:00
use Trinity\Bundle\MediaBundle\Model\Type ;
use Trinity\Bundle\MediaBundle\Model\TypePeer ;
use Trinity\Bundle\MediaBundle\Model\TypeQuery ;
use Trinity\Bundle\MediaBundle\Model\map\TypeTableMap ;
abstract class BaseTypePeer
{
/** the default database name for this class */
const DATABASE_NAME = 'default' ;
/** the table name for this class */
const TABLE_NAME = 'media_type' ;
/** the related Propel class for this table */
const OM_CLASS = 'Trinity\\Bundle\\MediaBundle\\Model\\Type' ;
/** the related TableMap class for this table */
const TM_CLASS = 'TypeTableMap' ;
/** The total number of columns. */
const NUM_COLUMNS = 9 ;
/** The number of lazy-loaded columns. */
const NUM_LAZY_LOAD_COLUMNS = 0 ;
/** The number of columns to hydrate (NUM_COLUMNS - NUM_LAZY_LOAD_COLUMNS) */
const NUM_HYDRATE_COLUMNS = 9 ;
/** the column name for the id field */
const ID = 'media_type.id' ;
/** the column name for the label field */
const LABEL = 'media_type.label' ;
/** the column name for the icon field */
const ICON = 'media_type.icon' ;
/** the column name for the thumbnail field */
const THUMBNAIL = 'media_type.thumbnail' ;
/** the column name for the mimes field */
const MIMES = 'media_type.mimes' ;
/** the column name for the created_at field */
const CREATED_AT = 'media_type.created_at' ;
/** the column name for the updated_at field */
const UPDATED_AT = 'media_type.updated_at' ;
/** the column name for the sortable_rank field */
const SORTABLE_RANK = 'media_type.sortable_rank' ;
/** the column name for the slug field */
const SLUG = 'media_type.slug' ;
/** The default string format for model objects of the related table **/
const DEFAULT_STRING_FORMAT = 'YAML' ;
/**
* An identiy map to hold any loaded instances of Type objects .
* This must be public so that other peer classes can access this when hydrating from JOIN
* queries .
* @ var array Type []
*/
public static $instances = array ();
// sortable behavior
/**
* rank column
*/
const RANK_COL = 'media_type.sortable_rank' ;
// uploadable behavior
protected static $uploadDirs = array (
'thumbnail' => 'uploads/media/type/thumbnail' ,
'icon' => 'uploads/media/type/icon' ,
);
/**
* holds an array of fieldnames
*
* first dimension keys are the type constants
* e . g . TypePeer :: $fieldNames [ TypePeer :: TYPE_PHPNAME ][ 0 ] = 'Id'
*/
protected static $fieldNames = array (
BasePeer :: TYPE_PHPNAME => array ( 'Id' , 'Label' , 'Icon' , 'Thumbnail' , 'Mimes' , 'CreatedAt' , 'UpdatedAt' , 'SortableRank' , 'Slug' , ),
BasePeer :: TYPE_STUDLYPHPNAME => array ( 'id' , 'label' , 'icon' , 'thumbnail' , 'mimes' , 'createdAt' , 'updatedAt' , 'sortableRank' , 'slug' , ),
BasePeer :: TYPE_COLNAME => array ( TypePeer :: ID , TypePeer :: LABEL , TypePeer :: ICON , TypePeer :: THUMBNAIL , TypePeer :: MIMES , TypePeer :: CREATED_AT , TypePeer :: UPDATED_AT , TypePeer :: SORTABLE_RANK , TypePeer :: SLUG , ),
BasePeer :: TYPE_RAW_COLNAME => array ( 'ID' , 'LABEL' , 'ICON' , 'THUMBNAIL' , 'MIMES' , 'CREATED_AT' , 'UPDATED_AT' , 'SORTABLE_RANK' , 'SLUG' , ),
BasePeer :: TYPE_FIELDNAME => array ( 'id' , 'label' , 'icon' , 'thumbnail' , 'mimes' , 'created_at' , 'updated_at' , 'sortable_rank' , 'slug' , ),
BasePeer :: TYPE_NUM => array ( 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , )
);
/**
* holds an array of keys for quick access to the fieldnames array
*
* first dimension keys are the type constants
* e . g . TypePeer :: $fieldNames [ BasePeer :: TYPE_PHPNAME ][ 'Id' ] = 0
*/
protected static $fieldKeys = array (
BasePeer :: TYPE_PHPNAME => array ( 'Id' => 0 , 'Label' => 1 , 'Icon' => 2 , 'Thumbnail' => 3 , 'Mimes' => 4 , 'CreatedAt' => 5 , 'UpdatedAt' => 6 , 'SortableRank' => 7 , 'Slug' => 8 , ),
BasePeer :: TYPE_STUDLYPHPNAME => array ( 'id' => 0 , 'label' => 1 , 'icon' => 2 , 'thumbnail' => 3 , 'mimes' => 4 , 'createdAt' => 5 , 'updatedAt' => 6 , 'sortableRank' => 7 , 'slug' => 8 , ),
BasePeer :: TYPE_COLNAME => array ( TypePeer :: ID => 0 , TypePeer :: LABEL => 1 , TypePeer :: ICON => 2 , TypePeer :: THUMBNAIL => 3 , TypePeer :: MIMES => 4 , TypePeer :: CREATED_AT => 5 , TypePeer :: UPDATED_AT => 6 , TypePeer :: SORTABLE_RANK => 7 , TypePeer :: SLUG => 8 , ),
BasePeer :: TYPE_RAW_COLNAME => array ( 'ID' => 0 , 'LABEL' => 1 , 'ICON' => 2 , 'THUMBNAIL' => 3 , 'MIMES' => 4 , 'CREATED_AT' => 5 , 'UPDATED_AT' => 6 , 'SORTABLE_RANK' => 7 , 'SLUG' => 8 , ),
BasePeer :: TYPE_FIELDNAME => array ( 'id' => 0 , 'label' => 1 , 'icon' => 2 , 'thumbnail' => 3 , 'mimes' => 4 , 'created_at' => 5 , 'updated_at' => 6 , 'sortable_rank' => 7 , 'slug' => 8 , ),
BasePeer :: TYPE_NUM => array ( 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , )
);
/**
* Translates a fieldname to another type
*
* @ param string $name field name
* @ param string $fromType One of the class type constants BasePeer :: TYPE_PHPNAME , BasePeer :: TYPE_STUDLYPHPNAME
* BasePeer :: TYPE_COLNAME , BasePeer :: TYPE_FIELDNAME , BasePeer :: TYPE_NUM
* @ param string $toType One of the class type constants
* @ return string translated name of the field .
* @ throws PropelException - if the specified name could not be found in the fieldname mappings .
*/
public static function translateFieldName ( $name , $fromType , $toType )
{
$toNames = TypePeer :: getFieldNames ( $toType );
$key = isset ( TypePeer :: $fieldKeys [ $fromType ][ $name ]) ? TypePeer :: $fieldKeys [ $fromType ][ $name ] : null ;
if ( $key === null ) {
throw new PropelException ( " ' $name ' could not be found in the field names of type ' $fromType '. These are: " . print_r ( TypePeer :: $fieldKeys [ $fromType ], true ));
}
return $toNames [ $key ];
}
/**
* Returns an array of field names .
*
* @ param string $type The type of fieldnames to return :
* One of the class type constants BasePeer :: TYPE_PHPNAME , BasePeer :: TYPE_STUDLYPHPNAME
* BasePeer :: TYPE_COLNAME , BasePeer :: TYPE_FIELDNAME , BasePeer :: TYPE_NUM
* @ return array A list of field names
* @ throws PropelException - if the type is not valid .
*/
public static function getFieldNames ( $type = BasePeer :: TYPE_PHPNAME )
{
if ( ! array_key_exists ( $type , TypePeer :: $fieldNames )) {
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.' );
}
return TypePeer :: $fieldNames [ $type ];
}
/**
* Convenience method which changes table . column to alias . column .
*
* Using this method you can maintain SQL abstraction while using column aliases .
* < code >
* $c -> addAlias ( " alias1 " , TablePeer :: TABLE_NAME );
* $c -> addJoin ( TablePeer :: alias ( " alias1 " , TablePeer :: PRIMARY_KEY_COLUMN ), TablePeer :: PRIMARY_KEY_COLUMN );
* </ code >
* @ param string $alias The alias for the current table .
* @ param string $column The column name for current table . ( i . e . TypePeer :: COLUMN_NAME ) .
* @ return string
*/
public static function alias ( $alias , $column )
{
return str_replace ( TypePeer :: TABLE_NAME . '.' , $alias . '.' , $column );
}
/**
* Add all the columns needed to create a new object .
*
* Note : any columns that were marked with lazyLoad = " true " in the
* XML schema will not be added to the select list and only loaded
* on demand .
*
* @ param Criteria $criteria object containing the columns to add .
* @ param string $alias optional table alias
* @ throws PropelException Any exceptions caught during processing will be
* rethrown wrapped into a PropelException .
*/
public static function addSelectColumns ( Criteria $criteria , $alias = null )
{
if ( null === $alias ) {
$criteria -> addSelectColumn ( TypePeer :: ID );
$criteria -> addSelectColumn ( TypePeer :: LABEL );
$criteria -> addSelectColumn ( TypePeer :: ICON );
$criteria -> addSelectColumn ( TypePeer :: THUMBNAIL );
$criteria -> addSelectColumn ( TypePeer :: MIMES );
$criteria -> addSelectColumn ( TypePeer :: CREATED_AT );
$criteria -> addSelectColumn ( TypePeer :: UPDATED_AT );
$criteria -> addSelectColumn ( TypePeer :: SORTABLE_RANK );
$criteria -> addSelectColumn ( TypePeer :: SLUG );
} else {
$criteria -> addSelectColumn ( $alias . '.id' );
$criteria -> addSelectColumn ( $alias . '.label' );
$criteria -> addSelectColumn ( $alias . '.icon' );
$criteria -> addSelectColumn ( $alias . '.thumbnail' );
$criteria -> addSelectColumn ( $alias . '.mimes' );
$criteria -> addSelectColumn ( $alias . '.created_at' );
$criteria -> addSelectColumn ( $alias . '.updated_at' );
$criteria -> addSelectColumn ( $alias . '.sortable_rank' );
$criteria -> addSelectColumn ( $alias . '.slug' );
}
}
/**
* Returns the number of rows matching criteria .
*
* @ param Criteria $criteria
* @ param boolean $distinct Whether to select only distinct columns ; deprecated : use Criteria -> setDistinct () instead .
* @ param PropelPDO $con
* @ return int Number of matching rows .
*/
public static function doCount ( Criteria $criteria , $distinct = false , PropelPDO $con = null )
{
// we may modify criteria, so copy it first
$criteria = clone $criteria ;
// We need to set the primary table name, since in the case that there are no WHERE columns
// it will be impossible for the BasePeer::createSelectSql() method to determine which
// tables go into the FROM clause.
$criteria -> setPrimaryTableName ( TypePeer :: TABLE_NAME );
if ( $distinct && ! in_array ( Criteria :: DISTINCT , $criteria -> getSelectModifiers ())) {
$criteria -> setDistinct ();
}
if ( ! $criteria -> hasSelectClause ()) {
TypePeer :: addSelectColumns ( $criteria );
}
$criteria -> clearOrderByColumns (); // ORDER BY won't ever affect the count
$criteria -> setDbName ( TypePeer :: DATABASE_NAME ); // Set the correct dbName
if ( $con === null ) {
$con = Propel :: getConnection ( TypePeer :: DATABASE_NAME , Propel :: CONNECTION_READ );
}
// BasePeer returns a PDOStatement
$stmt = BasePeer :: doCount ( $criteria , $con );
if ( $row = $stmt -> fetch ( PDO :: FETCH_NUM )) {
$count = ( int ) $row [ 0 ];
} else {
$count = 0 ; // no rows returned; we infer that means 0 matches.
}
$stmt -> closeCursor ();
return $count ;
}
/**
* Selects one object from the DB .
*
* @ param Criteria $criteria object used to create the SELECT statement .
* @ param PropelPDO $con
* @ return Type
* @ throws PropelException Any exceptions caught during processing will be
* rethrown wrapped into a PropelException .
*/
public static function doSelectOne ( Criteria $criteria , PropelPDO $con = null )
{
$critcopy = clone $criteria ;
$critcopy -> setLimit ( 1 );
$objects = TypePeer :: doSelect ( $critcopy , $con );
if ( $objects ) {
return $objects [ 0 ];
}
return null ;
}
/**
* Selects several row from the DB .
*
* @ param Criteria $criteria The Criteria object used to build the SELECT statement .
* @ param PropelPDO $con
* @ return array Array of selected Objects
* @ throws PropelException Any exceptions caught during processing will be
* rethrown wrapped into a PropelException .
*/
public static function doSelect ( Criteria $criteria , PropelPDO $con = null )
{
return TypePeer :: populateObjects ( TypePeer :: doSelectStmt ( $criteria , $con ));
}
/**
* Prepares the Criteria object and uses the parent doSelect () method to execute a PDOStatement .
*
* Use this method directly if you want to work with an executed statement directly ( for example
* to perform your own object hydration ) .
*
* @ param Criteria $criteria The Criteria object used to build the SELECT statement .
* @ param PropelPDO $con The connection to use
* @ throws PropelException Any exceptions caught during processing will be
* rethrown wrapped into a PropelException .
* @ return PDOStatement The executed PDOStatement object .
* @ see BasePeer :: doSelect ()
*/
public static function doSelectStmt ( Criteria $criteria , PropelPDO $con = null )
{
if ( $con === null ) {
$con = Propel :: getConnection ( TypePeer :: DATABASE_NAME , Propel :: CONNECTION_READ );
}
if ( ! $criteria -> hasSelectClause ()) {
$criteria = clone $criteria ;
TypePeer :: addSelectColumns ( $criteria );
}
// Set the correct dbName
$criteria -> setDbName ( TypePeer :: DATABASE_NAME );
// BasePeer returns a PDOStatement
return BasePeer :: doSelect ( $criteria , $con );
}
/**
* Adds an object to the instance pool .
*
* Propel keeps cached copies of objects in an instance pool when they are retrieved
* from the database . In some cases -- especially when you override doSelect * ()
* methods in your stub classes -- you may need to explicitly add objects
* to the cache in order to ensure that the same objects are always returned by doSelect * ()
* and retrieveByPK * () calls .
*
* @ param Type $obj A Type object .
* @ param string $key ( optional ) key to use for instance map ( for performance boost if key was already calculated externally ) .
*/
public static function addInstanceToPool ( $obj , $key = null )
{
if ( Propel :: isInstancePoolingEnabled ()) {
if ( $key === null ) {
$key = ( string ) $obj -> getId ();
} // if key === null
TypePeer :: $instances [ $key ] = $obj ;
}
}
/**
* Removes an object from the instance pool .
*
* Propel keeps cached copies of objects in an instance pool when they are retrieved
* from the database . In some cases -- especially when you override doDelete
* methods in your stub classes -- you may need to explicitly remove objects
* from the cache in order to prevent returning objects that no longer exist .
*
* @ param mixed $value A Type object or a primary key value .
*
* @ return void
* @ throws PropelException - if the value is invalid .
*/
public static function removeInstanceFromPool ( $value )
{
if ( Propel :: isInstancePoolingEnabled () && $value !== null ) {
if ( is_object ( $value ) && $value instanceof Type ) {
$key = ( string ) $value -> getId ();
} elseif ( is_scalar ( $value )) {
// assume we've been passed a primary key
$key = ( string ) $value ;
} else {
$e = new PropelException ( " Invalid value passed to removeInstanceFromPool(). Expected primary key or Type object; got " . ( is_object ( $value ) ? get_class ( $value ) . ' object.' : var_export ( $value , true )));
throw $e ;
}
unset ( TypePeer :: $instances [ $key ]);
}
} // removeInstanceFromPool()
/**
* 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 .
*
* For tables with a single - column primary key , that simple pkey value will be returned . For tables with
* a multi - column primary key , a serialize () d version of the primary key will be returned .
*
* @ param string $key The key ( @ see getPrimaryKeyHash ()) for this instance .
* @ return Type Found object or null if 1 ) no instance exists for specified key or 2 ) instance pooling has been disabled .
* @ see getPrimaryKeyHash ()
*/
public static function getInstanceFromPool ( $key )
{
if ( Propel :: isInstancePoolingEnabled ()) {
if ( isset ( TypePeer :: $instances [ $key ])) {
return TypePeer :: $instances [ $key ];
}
}
return null ; // just to be explicit
}
/**
* Clear the instance pool .
*
* @ return void
*/
public static function clearInstancePool ( $and_clear_all_references = false )
{
if ( $and_clear_all_references )
{
foreach ( TypePeer :: $instances as $instance )
{
$instance -> clearAllReferences ( true );
}
}
TypePeer :: $instances = array ();
}
/**
* Method to invalidate the instance pool of all tables related to media_type
* by a foreign key with ON DELETE CASCADE
*/
public static function clearRelatedInstancePool ()
{
2015-11-25 18:28:10 +01:00
// Invalidate objects in MediaPeer instance pool,
// since one or more of them may be deleted by ON DELETE CASCADE/SETNULL rule.
MediaPeer :: clearInstancePool ();
2015-03-02 21:57:49 +01:00
}
/**
* 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 .
*
* For tables with a single - column primary key , that simple pkey value will be returned . For tables with
* a multi - column primary key , a serialize () d version of the primary key will be returned .
*
* @ param array $row PropelPDO resultset row .
* @ param int $startcol The 0 - based offset for reading from the resultset row .
* @ return string A string version of PK or null if the components of primary key in result array are all null .
*/
public static function getPrimaryKeyHashFromRow ( $row , $startcol = 0 )
{
// If the PK cannot be derived from the row, return null.
if ( $row [ $startcol ] === null ) {
return null ;
}
return ( string ) $row [ $startcol ];
}
/**
* Retrieves the primary key from the DB resultset row
* For tables with a single - column primary key , that simple pkey value will be returned . For tables with
* a multi - column primary key , an array of the primary key columns will be returned .
*
* @ param array $row PropelPDO resultset row .
* @ param int $startcol The 0 - based offset for reading from the resultset row .
* @ return mixed The primary key of the row
*/
public static function getPrimaryKeyFromRow ( $row , $startcol = 0 )
{
return ( int ) $row [ $startcol ];
}
/**
* The returned array will contain objects of the default type or
* objects that inherit from the default .
*
* @ throws PropelException Any exceptions caught during processing will be
* rethrown wrapped into a PropelException .
*/
public static function populateObjects ( PDOStatement $stmt )
{
$results = array ();
// set the class once to avoid overhead in the loop
$cls = TypePeer :: getOMClass ();
// populate the object(s)
while ( $row = $stmt -> fetch ( PDO :: FETCH_NUM )) {
$key = TypePeer :: getPrimaryKeyHashFromRow ( $row , 0 );
if ( null !== ( $obj = TypePeer :: getInstanceFromPool ( $key ))) {
// We no longer rehydrate the object, since this can cause data loss.
// See http://www.propelorm.org/ticket/509
// $obj->hydrate($row, 0, true); // rehydrate
$results [] = $obj ;
} else {
$obj = new $cls ();
$obj -> hydrate ( $row );
$results [] = $obj ;
TypePeer :: addInstanceToPool ( $obj , $key );
} // if key exists
}
$stmt -> closeCursor ();
return $results ;
}
/**
* Populates an object of the default type or an object that inherit from the default .
*
* @ param array $row PropelPDO resultset row .
* @ param int $startcol The 0 - based offset for reading from the resultset row .
* @ throws PropelException Any exceptions caught during processing will be
* rethrown wrapped into a PropelException .
* @ return array ( Type object , last column rank )
*/
public static function populateObject ( $row , $startcol = 0 )
{
$key = TypePeer :: getPrimaryKeyHashFromRow ( $row , $startcol );
if ( null !== ( $obj = TypePeer :: getInstanceFromPool ( $key ))) {
// We no longer rehydrate the object, since this can cause data loss.
// See http://www.propelorm.org/ticket/509
// $obj->hydrate($row, $startcol, true); // rehydrate
$col = $startcol + TypePeer :: NUM_HYDRATE_COLUMNS ;
} else {
$cls = TypePeer :: OM_CLASS ;
$obj = new $cls ();
$col = $obj -> hydrate ( $row , $startcol );
TypePeer :: addInstanceToPool ( $obj , $key );
}
return array ( $obj , $col );
}
/**
* Returns the TableMap related to this peer .
* This method is not needed for general use but a specific application could have a need .
* @ return TableMap
* @ throws PropelException Any exceptions caught during processing will be
* rethrown wrapped into a PropelException .
*/
public static function getTableMap ()
{
return Propel :: getDatabaseMap ( TypePeer :: DATABASE_NAME ) -> getTable ( TypePeer :: TABLE_NAME );
}
/**
* Add a TableMap instance to the database for this peer class .
*/
public static function buildTableMap ()
{
$dbMap = Propel :: getDatabaseMap ( BaseTypePeer :: DATABASE_NAME );
if ( ! $dbMap -> hasTable ( BaseTypePeer :: TABLE_NAME )) {
$dbMap -> addTableObject ( new TypeTableMap ());
}
}
/**
* The class that the Peer will make instances of .
*
*
* @ return string ClassName
*/
public static function getOMClass ( $row = 0 , $colnum = 0 )
{
return TypePeer :: OM_CLASS ;
}
/**
* Performs an INSERT on the database , given a Type or Criteria object .
*
* @ param mixed $values Criteria or Type object containing data that is used to create the INSERT statement .
* @ param PropelPDO $con the PropelPDO connection to use
* @ return mixed The new primary key .
* @ throws PropelException Any exceptions caught during processing will be
* rethrown wrapped into a PropelException .
*/
public static function doInsert ( $values , PropelPDO $con = null )
{
if ( $con === null ) {
$con = Propel :: getConnection ( TypePeer :: DATABASE_NAME , Propel :: CONNECTION_WRITE );
}
if ( $values instanceof Criteria ) {
$criteria = clone $values ; // rename for clarity
} else {
$criteria = $values -> buildCriteria (); // build Criteria from Type object
}
if ( $criteria -> containsKey ( TypePeer :: ID ) && $criteria -> keyContainsValue ( TypePeer :: ID ) ) {
throw new PropelException ( 'Cannot insert a value for auto-increment primary key (' . TypePeer :: ID . ')' );
}
// Set the correct dbName
$criteria -> setDbName ( TypePeer :: DATABASE_NAME );
try {
// use transaction because $criteria could contain info
// for more than one table (I guess, conceivably)
$con -> beginTransaction ();
$pk = BasePeer :: doInsert ( $criteria , $con );
$con -> commit ();
} catch ( PropelException $e ) {
$con -> rollBack ();
throw $e ;
}
return $pk ;
}
/**
* Performs an UPDATE on the database , given a Type or Criteria object .
*
* @ param mixed $values Criteria or Type object containing data that is used to create the UPDATE statement .
* @ param PropelPDO $con The connection to use ( specify PropelPDO connection object to exert more control over transactions ) .
* @ return int The number of affected rows ( if supported by underlying database driver ) .
* @ throws PropelException Any exceptions caught during processing will be
* rethrown wrapped into a PropelException .
*/
public static function doUpdate ( $values , PropelPDO $con = null )
{
if ( $con === null ) {
$con = Propel :: getConnection ( TypePeer :: DATABASE_NAME , Propel :: CONNECTION_WRITE );
}
$selectCriteria = new Criteria ( TypePeer :: DATABASE_NAME );
if ( $values instanceof Criteria ) {
$criteria = clone $values ; // rename for clarity
$comparison = $criteria -> getComparison ( TypePeer :: ID );
$value = $criteria -> remove ( TypePeer :: ID );
if ( $value ) {
$selectCriteria -> add ( TypePeer :: ID , $value , $comparison );
} else {
$selectCriteria -> setPrimaryTableName ( TypePeer :: TABLE_NAME );
}
} else { // $values is Type object
$criteria = $values -> buildCriteria (); // gets full criteria
$selectCriteria = $values -> buildPkeyCriteria (); // gets criteria w/ primary key(s)
}
// set the correct dbName
$criteria -> setDbName ( TypePeer :: DATABASE_NAME );
return BasePeer :: doUpdate ( $selectCriteria , $criteria , $con );
}
/**
* Deletes all rows from the media_type table .
*
* @ param PropelPDO $con the connection to use
* @ return int The number of affected rows ( if supported by underlying database driver ) .
* @ throws PropelException
*/
public static function doDeleteAll ( PropelPDO $con = null )
{
if ( $con === null ) {
$con = Propel :: getConnection ( TypePeer :: DATABASE_NAME , Propel :: CONNECTION_WRITE );
}
$affectedRows = 0 ; // initialize var to track total num of affected rows
try {
// use transaction because $criteria could contain info
// for more than one table or we could emulating ON DELETE CASCADE, etc.
$con -> beginTransaction ();
2015-11-25 18:28:10 +01:00
TypePeer :: doOnDeleteSetNull ( new Criteria ( TypePeer :: DATABASE_NAME ), $con );
2015-03-02 21:57:49 +01:00
$affectedRows += BasePeer :: doDeleteAll ( TypePeer :: TABLE_NAME , $con , TypePeer :: DATABASE_NAME );
// Because this db requires some delete cascade/set null emulation, we have to
// clear the cached instance *after* the emulation has happened (since
// instances get re-added by the select statement contained therein).
TypePeer :: clearInstancePool ();
TypePeer :: clearRelatedInstancePool ();
$con -> commit ();
return $affectedRows ;
} catch ( PropelException $e ) {
$con -> rollBack ();
throw $e ;
}
}
/**
* Performs a DELETE on the database , given a Type or Criteria object OR a primary key value .
*
* @ param mixed $values Criteria or Type object or primary key or array of primary keys
* which is used to create the DELETE statement
* @ param PropelPDO $con the connection to use
* @ return int The number of affected rows ( if supported by underlying database driver ) . This includes CASCADE - related rows
* if supported by native driver or if emulated using Propel .
* @ throws PropelException Any exceptions caught during processing will be
* rethrown wrapped into a PropelException .
*/
public static function doDelete ( $values , PropelPDO $con = null )
{
if ( $con === null ) {
$con = Propel :: getConnection ( TypePeer :: DATABASE_NAME , Propel :: CONNECTION_WRITE );
}
if ( $values instanceof Criteria ) {
// rename for clarity
$criteria = clone $values ;
} elseif ( $values instanceof Type ) { // it's a model object
// create criteria based on pk values
$criteria = $values -> buildPkeyCriteria ();
} else { // it's a primary key, or an array of pks
$criteria = new Criteria ( TypePeer :: DATABASE_NAME );
$criteria -> add ( TypePeer :: ID , ( array ) $values , Criteria :: IN );
}
// Set the correct dbName
$criteria -> setDbName ( TypePeer :: DATABASE_NAME );
$affectedRows = 0 ; // initialize var to track total num of affected rows
try {
// use transaction because $criteria could contain info
// for more than one table or we could emulating ON DELETE CASCADE, etc.
$con -> beginTransaction ();
2015-11-25 18:28:10 +01:00
// cloning the Criteria in case it's modified by doSelect() or doSelectStmt()
$c = clone $criteria ;
TypePeer :: doOnDeleteSetNull ( $c , $con );
// Because this db requires some delete cascade/set null emulation, we have to
// clear the cached instance *after* the emulation has happened (since
// instances get re-added by the select statement contained therein).
if ( $values instanceof Criteria ) {
TypePeer :: clearInstancePool ();
} elseif ( $values instanceof Type ) { // it's a model object
TypePeer :: removeInstanceFromPool ( $values );
} else { // it's a primary key, or an array of pks
foreach (( array ) $values as $singleval ) {
TypePeer :: removeInstanceFromPool ( $singleval );
}
}
2015-03-02 21:57:49 +01:00
$affectedRows += BasePeer :: doDelete ( $criteria , $con );
TypePeer :: clearRelatedInstancePool ();
$con -> commit ();
return $affectedRows ;
} catch ( PropelException $e ) {
$con -> rollBack ();
throw $e ;
}
}
2015-11-25 18:28:10 +01:00
/**
* This is a method for emulating ON DELETE SET NULL DBs that don ' t support this
* feature ( like MySQL or SQLite ) .
*
* This method is not very speedy because it must perform a query first to get
* the implicated records and then perform the deletes by calling those Peer classes .
*
* This method should be used within a transaction if possible .
*
* @ param Criteria $criteria
* @ param PropelPDO $con
* @ return void
*/
protected static function doOnDeleteSetNull ( Criteria $criteria , PropelPDO $con )
{
// first find the objects that are implicated by the $criteria
$objects = TypePeer :: doSelect ( $criteria , $con );
foreach ( $objects as $obj ) {
// set fkey col in related Media rows to null
$selectCriteria = new Criteria ( TypePeer :: DATABASE_NAME );
$updateValues = new Criteria ( TypePeer :: DATABASE_NAME );
$selectCriteria -> add ( MediaPeer :: TYPE_ID , $obj -> getId ());
$updateValues -> add ( MediaPeer :: TYPE_ID , null );
BasePeer :: doUpdate ( $selectCriteria , $updateValues , $con ); // use BasePeer because generated Peer doUpdate() methods only update using pkey
}
}
2015-03-02 21:57:49 +01:00
/**
* Validates all modified columns of given Type object .
* If parameter $columns is either a single column name or an array of column names
* than only those columns are validated .
*
* NOTICE : This does not apply to primary or foreign keys for now .
*
* @ param Type $obj The object to validate .
* @ param mixed $cols Column name or array of column names .
*
* @ return mixed TRUE if all columns are valid or the error message of the first invalid column .
*/
public static function doValidate ( $obj , $cols = null )
{
$columns = array ();
if ( $cols ) {
$dbMap = Propel :: getDatabaseMap ( TypePeer :: DATABASE_NAME );
$tableMap = $dbMap -> getTable ( TypePeer :: TABLE_NAME );
if ( ! is_array ( $cols )) {
$cols = array ( $cols );
}
foreach ( $cols as $colName ) {
if ( $tableMap -> hasColumn ( $colName )) {
$get = 'get' . $tableMap -> getColumn ( $colName ) -> getPhpName ();
$columns [ $colName ] = $obj -> $get ();
}
}
} else {
}
return BasePeer :: doValidate ( TypePeer :: DATABASE_NAME , TypePeer :: TABLE_NAME , $columns );
}
/**
* Retrieve a single object by pkey .
*
* @ param int $pk the primary key .
* @ param PropelPDO $con the connection to use
* @ return Type
*/
public static function retrieveByPK ( $pk , PropelPDO $con = null )
{
if ( null !== ( $obj = TypePeer :: getInstanceFromPool (( string ) $pk ))) {
return $obj ;
}
if ( $con === null ) {
$con = Propel :: getConnection ( TypePeer :: DATABASE_NAME , Propel :: CONNECTION_READ );
}
$criteria = new Criteria ( TypePeer :: DATABASE_NAME );
$criteria -> add ( TypePeer :: ID , $pk );
$v = TypePeer :: doSelect ( $criteria , $con );
return ! empty ( $v ) > 0 ? $v [ 0 ] : null ;
}
/**
* Retrieve multiple objects by pkey .
*
* @ param array $pks List of primary keys
* @ param PropelPDO $con the connection to use
* @ return Type []
* @ throws PropelException Any exceptions caught during processing will be
* rethrown wrapped into a PropelException .
*/
public static function retrieveByPKs ( $pks , PropelPDO $con = null )
{
if ( $con === null ) {
$con = Propel :: getConnection ( TypePeer :: DATABASE_NAME , Propel :: CONNECTION_READ );
}
$objs = null ;
if ( empty ( $pks )) {
$objs = array ();
} else {
$criteria = new Criteria ( TypePeer :: DATABASE_NAME );
$criteria -> add ( TypePeer :: ID , $pks , Criteria :: IN );
$objs = TypePeer :: doSelect ( $criteria , $con );
}
return $objs ;
}
// sortable behavior
/**
* Get the highest rank
*
* @ param PropelPDO optional connection
*
* @ return integer highest position
*/
public static function getMaxRank ( PropelPDO $con = null )
{
if ( $con === null ) {
$con = Propel :: getConnection ( TypePeer :: DATABASE_NAME );
}
// shift the objects with a position lower than the one of object
$c = new Criteria ();
$c -> addSelectColumn ( 'MAX(' . TypePeer :: RANK_COL . ')' );
$stmt = TypePeer :: doSelectStmt ( $c , $con );
return $stmt -> fetchColumn ();
}
/**
* Get an item from the list based on its rank
*
* @ param integer $rank rank
* @ param PropelPDO $con optional connection
*
* @ return Type
*/
public static function retrieveByRank ( $rank , PropelPDO $con = null )
{
if ( $con === null ) {
$con = Propel :: getConnection ( TypePeer :: DATABASE_NAME );
}
$c = new Criteria ;
$c -> add ( TypePeer :: RANK_COL , $rank );
return TypePeer :: doSelectOne ( $c , $con );
}
/**
* Reorder a set of sortable objects based on a list of id / position
* Beware that there is no check made on the positions passed
* So incoherent positions will result in an incoherent list
*
* @ param array $order id => rank pairs
* @ param PropelPDO $con optional connection
*
* @ return boolean true if the reordering took place , false if a database problem prevented it
*/
public static function reorder ( array $order , PropelPDO $con = null )
{
if ( $con === null ) {
$con = Propel :: getConnection ( TypePeer :: DATABASE_NAME );
}
$con -> beginTransaction ();
try {
$ids = array_keys ( $order );
$objects = TypePeer :: retrieveByPKs ( $ids );
foreach ( $objects as $object ) {
$pk = $object -> getPrimaryKey ();
if ( $object -> getSortableRank () != $order [ $pk ]) {
$object -> setSortableRank ( $order [ $pk ]);
$object -> save ( $con );
}
}
$con -> commit ();
return true ;
} catch ( PropelException $e ) {
$con -> rollback ();
throw $e ;
}
}
/**
* Return an array of sortable objects ordered by position
*
* @ param Criteria $criteria optional criteria object
* @ param string $order sorting order , to be chosen between Criteria :: ASC ( default ) and Criteria :: DESC
* @ param PropelPDO $con optional connection
*
* @ return array list of sortable objects
*/
public static function doSelectOrderByRank ( Criteria $criteria = null , $order = Criteria :: ASC , PropelPDO $con = null )
{
if ( $con === null ) {
$con = Propel :: getConnection ( TypePeer :: DATABASE_NAME );
}
if ( $criteria === null ) {
$criteria = new Criteria ();
} elseif ( $criteria instanceof Criteria ) {
$criteria = clone $criteria ;
}
$criteria -> clearOrderByColumns ();
if ( $order == Criteria :: ASC ) {
$criteria -> addAscendingOrderByColumn ( TypePeer :: RANK_COL );
} else {
$criteria -> addDescendingOrderByColumn ( TypePeer :: RANK_COL );
}
return TypePeer :: doSelect ( $criteria , $con );
}
/**
* Adds $delta to all Rank values that are >= $first and <= $last .
* '$delta' can also be negative .
*
* @ param int $delta Value to be shifted by , can be negative
* @ param int $first First node to be shifted
* @ param int $last Last node to be shifted
* @ param PropelPDO $con Connection to use .
*/
public static function shiftRank ( $delta , $first = null , $last = null , PropelPDO $con = null )
{
if ( $con === null ) {
$con = Propel :: getConnection ( TypePeer :: DATABASE_NAME , Propel :: CONNECTION_WRITE );
}
$whereCriteria = TypeQuery :: create ();
if ( null !== $first ) {
$whereCriteria -> add ( TypePeer :: RANK_COL , $first , Criteria :: GREATER_EQUAL );
}
if ( null !== $last ) {
$whereCriteria -> addAnd ( TypePeer :: RANK_COL , $last , Criteria :: LESS_EQUAL );
}
$valuesCriteria = new Criteria ( TypePeer :: DATABASE_NAME );
$valuesCriteria -> add ( TypePeer :: RANK_COL , array ( 'raw' => TypePeer :: RANK_COL . ' + ?' , 'value' => $delta ), Criteria :: CUSTOM_EQUAL );
BasePeer :: doUpdate ( $whereCriteria , $valuesCriteria , $con );
TypePeer :: clearInstancePool ();
}
// uploadable behavior
/**
* Return the upload dir of $field field
*
* @ return string
*
*/
public static function getUploadDir ( $field )
{
return self :: $uploadDirs [ $field ];
}
} // BaseTypePeer
// This is the static code needed to register the TableMap for this table with the main Propel class.
//
BaseTypePeer :: buildTableMap ();