Ticket #3883: sfPropelFinder.php

<?php

/*
 * This file is part of the sfPropelFinder package.
 * 
 * (c) 2007 François Zaninotto <francois.zaninotto@symfony-project.com>
 * 
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
 
class sfPropelFinder
{
  protected $peerClass = null;
  protected $databaseMap = null;
  protected $criteria = null;
  protected $relations = null;
  protected $latestQuery = '';
  protected $criterions = array();
  protected $withClasses = array();
  protected $withColumns = array();

  public function __construct($class = '')
  {
    $this->criteria = new Criteria();
    if($class)
    {
      $this->setPeerClass($class.'Peer');
    }
    if($this->peerClass)
    {
      $this->initialize();
    }
  }
  
  public function initialize()
  {
    $mapBuilder = call_user_func(array($this->peerClass, 'getMapBuilder'));
    $mapBuilder->doBuild();
    $this->databaseMap = $mapBuilder->getDatabaseMap();
  }
  
  public function getPeerClass()
  {
    return $this->peerClass;
  }

  public function setPeerClass($peerClass)
  {
    $this->relations[]= $peerClass;
    $this->peerClass = $peerClass;
    
    return $this;
  }
  
  public function getCriteria()
  {
    return $this->buildCriteria();
  }
  
  public function setCriteria($criteria)
  {
    $this->criteria = $criteria;
    $this->criterions = array();
    
    return $this;
  }

  public function reinitCriteria()
  { 
    return $this->setCriteria(new Criteria());
  }
  
  public function getLatestQuery()
  {
    $con = Propel::getConnection();
    if(method_exists($con, 'getLastExecutedQuery'))
    {
      return $this->latestQuery;
    }
    else
    {
      throw new Exception('getLatestQuery() only works when debug mode is enabled');
    }
  }
  
  public function updateLatestQuery()
  {
    $con = Propel::getConnection();
    if(method_exists($con, 'getLastExecutedQuery'))
    {
      $this->latestQuery = $con->getLastExecutedQuery();
    }
  }
  
  public function addWithClass($class)
  {
    $this->withClasses []= $class;
    
    return $this;
  }
  
  public function getWithClasses()
  {
    return $this->withClasses;
  }
  
  public function reinitWithClasses()
  {
    $this->withClasses = array();
    
    return $this;
  }

  public function getWithColumns()
  {
    return $this->withColumns;
  }
  
  public function reinitWithColumns()
  {
    $this->withColumns = array();
    
    return $this;
  }
  
  // Finder Initializers
  
  /**
   * Mixed initializer
   * Accepts either a string (Propel class) or an array of Propel objects
   *
   * @param mixed $from The data to initialize the finder with
   * @return sfPropelFinder a finder object
   * @throws Exception If the data is neither a classname nor an array
   */
  public static function from($from)
  {
    if (is_string($from))
    {
      return self::fromClass($from);
    }
    if (is_array($from))
    {
      return self::fromCollection($from);
    }
    throw new Exception('from() only accepts a Propel object classname or an array of Propel objects');
  }

  /**
   * Class initializer
   *
   * @param string $from Propel classname on which the search will be done
   * @return sfPropelFinder a finder object
   */
  public static function fromClass($class)
  {
    $me = __CLASS__;
    $finder = new $me($class);
    
    return $finder;
  }
  
  /**
   * Collection initializer
   *
   * @param array $from Array of Propel objects of the same class
   * @param string $class Optional classname of the desired objects
   * @param string $class Optional column name of the primary key
   *
   * @return sfPropelFinder a finder object
   * @throws Exception If the array is empty, contains not Propel objects or composite objects
   */
  public static function fromCollection($collection, $class = '', $pkName = '')
  {
    $pks = array();
    foreach($collection as $object)
    {
      if($class != get_class($object))
      {
        if($class)
        {
          throw new Exception('A finder can only be initialized from an array of objects of a single class');
        }
        if($object instanceof BaseObject)
        {
          $class = get_class($object);
        }
        else
        {
          throw new Exception('A finder can only be initialized from an array of Propel objects');
        }
      }
      $pks []= $object->getPrimaryKey();
    }
    if(!$class)
    {
      throw new Exception('A finder cannot be initialized with an empty array');
    }
    
    $tempObject = new $class();
    foreach ($tempObject->getPeer()->getTableMap()->getColumns() as $column)
    {
      if($column->isPrimaryKey())
      {
        if($pkName)
        {
          throw new Exception('A finder cannot be initialized from an array of objects with several foreign keys');
        }
        else
        {
          $pkName = $column->getFullyQualifiedName();
        }
      }
    }
    
    return self::fromArray($pks, $class, $pkName);
  }
  
  /**
   * Array initializer
   *
   * @param array $array Array of Primary keys
   * @param string $class Propel classname on which the search will be done
   *
   * @return sfPropelFinder a finder object
   */
  public static function fromArray($array, $class, $pkName)
  {
    $finder = self::fromClass($class);
    $finder->add($pkName, $array, Criteria::IN);
    
    return $finder;
  }
  
  // Finder Executers
  
  public function count($con = null, $reinitCriteria = true)
  {
    $ret = call_user_func(array($this->getPeerClass(), 'doCount'), $this->getCriteria(), $con);
    $this->updateLatestQuery();
    if($reinitCriteria)
    {
      $this->reinitCriteria();
    }
    
    return $ret;
  }
  
  public function find($limit = null, $con = null, $reinitCriteria = false)
  {
    if($limit)
    {
      $this->criteria->setLimit($limit);
    }
    $ret = $this->doFind($this->getCriteria(), $con);
    $this->updateLatestQuery();
    if($reinitCriteria)
    {
      $this->reinitCriteria();
    }
    
    return $ret;
  }
  
  public function findOne($con = null, $reinitCriteria = true)
  {
    $this->criteria->setLimit(1);
    $ret = $this->doFind($this->getCriteria(), $con);
    $this->updateLatestQuery();
    if($reinitCriteria)
    {
      $this->reinitCriteria();
    }
    if ($ret)
    {
      return $ret[0];
    }
    return null;
  }
  
  public function findLast($column = null, $con = null, $reinitCriteria = true)
  {
    if($column)
    {
      $this->orderBy($column, 'desc');
    }
    else
    {
      $this->guessOrder('desc');
    }
    
    return $this->findOne($con, $reinitCriteria);
  }
  
  public function findFirst($column = null, $con = null, $reinitCriteria = true)
  {
    if($column)
    {
      $this->orderBy($column, 'asc');
    }
    else
    {
      $this->guessOrder('asc');
    }
    
    return $this->findOne($con, $reinitCriteria);
  }

  protected function guessOrder($direction = 'desc')
  {
    $columnNames = array();
    foreach ($this->getColumnsForPeerClass($this->getPeerClass()) as $c)
    {
      $columnNames []= $c->getPhpName();
    }
    foreach(sfConfig::get('app_sfPropelFinder_sort_column_guesses', array('UpdatedAt', 'UpdatedOn', 'CreatedAt', 'CreatedOn', 'Id')) as $testColumnName)
    {
      if(in_array($testColumnName, $columnNames))
      {
        $this->orderBy($testColumnName, $direction);
        return;
      }
    }
    
    throw new Exception('Unable to figure out the column to use to order rows');
  }
  
  public function findBy($columnName, $value, $limit = null, $con = null, $reinitCriteria = false)
  {
    $column = $this->getColName($columnName);
    $this->addCondition('and', $column, $value, Criteria::EQUAL);
    
    return $this->find($limit, $con, $reinitCriteria);
  }

  public function findOneBy($columnName, $value, $con = null, $reinitCriteria = false)
  {
    $column = $this->getColName($columnName);
    $this->addCondition('and', $column, $value, Criteria::EQUAL);
    
    return $this->findOne($con, $reinitCriteria);
  }
  
  public function findPk($pk, $con = null)
  {
    if(is_array($pk))
    {
      $ret = call_user_func(array($this->getPeerClass(), 'retrieveByPks'), $pk, $con);
    }
    else
    {
      $ret = call_user_func(array($this->getPeerClass(), 'retrieveByPk'), $pk, $con);
    }
    $this->updateLatestQuery();
    
    return $ret;
  }
  
  public function doFind($criteria, $con = null)
  {
    if($this->getWithClasses() || $this->getWithColumns())
    {
      $c = $this->prepareCompositeCriteria($criteria);
      $resultSet = call_user_func(array($this->getPeerClass(), 'doSelectRS'), $c, $con);
      
      // Hydrate the objects based on the resultset
      $omClass = call_user_func(array($this->getPeerClass(), 'getOMClass'));
      $cls = Propel::import($omClass);
      $objects = array();
      $withObjs = array();
      while ($resultSet->next())
      {
        // First come the columns of the main class
        $obj = new $cls();
        $startCol = $obj->hydrate($resultSet, 1);
        // Then the related classes added by way of 'with'
        $objectsInJoin = array($obj);
        foreach ($this->getWithClasses() as $className)
        {
          $withObj = new $className();
          $startCol = $withObj->hydrate($resultSet, $startCol);
          
          // initialize our object directory
          if (!isset($withObjs[$className]))
          {
            $withObjs[$className] = array();
          }
          
          // check if object is not already referenced in allObjects directory
          $isNewObject = true;
          foreach ($withObjs[$className] as $otherObject)
          {
            if ($otherObject->getPrimaryKey() === $withObj->getPrimaryKey())
            {
              $isNewObject = false;
              $withObj = $otherObject;
              break;
            }
          }
          $this->relateObjects($withObj, $objectsInJoin, $isNewObject);
          $objectsInJoin []= $withObj;
          if ($isNewObject)
          {
            $withObjs[$className][] = $withObj;
          }
        }
        // Then the columns added one by one by way of 'withColumn'
        foreach($this->getWithColumns() as $name => $column)
        {
          // Additional columns are stored in the object, in a special 'namespace'
          // see getColumn() for how to retrieve the value afterwards
          $asName = 'WithColumn'.$name;
          // Using the third parameter of withColumn() as a type. defaults to $rs->get() (= $rs->getString())
          $typedGetter = 'get'.ucfirst($column['type']);
          $obj->$asName = $resultSet->$typedGetter($startCol);
          $startCol++;
        }
        
        $objects []= $obj;
      }
      
      // activate custom column getter if asColumns were added
      if($this->getWithColumns() && !sfMixer::getCallable('Base'.$cls.':getColumn'))
      {
        sfMixer::register('Base'.$cls, array($this, 'getColumn'));
      }
      
      return $objects;
    }
    else
    {
      // No 'with', so we use the native Propel doSelect()
      return call_user_func(array($this->getPeerClass(), 'doSelect'), $criteria, $con);
    }
  }
  
  /**
   * Prepare the select columns and add the missing joins
   */
  protected function prepareCompositeCriteria($criteria)
  {
    $c = clone $criteria;
    $c->clearSelectColumns();
    // First come the columns of the main class
    call_user_func(array($this->getPeerClass(), 'addSelectColumns'), $c);
    // Then the related classes added by way of 'with'
    foreach ($this->getWithClasses() as $className)
    {
      $tempClass = new $className();
      call_user_func(array($tempClass->getPeer(), 'addSelectColumns'), $c);
      // if join() wasn't called previously on this class, do a simple join
      if(!in_array($className.'Peer', $this->relations))
      {
        list($column1, $column2) = $this->getRelation($className);
        $c->addJoin($column1, $column2);
        $this->relations[]= $className.'Peer';
      }
    }
    // Then the columns added one by one by way of 'withColumn'
    foreach($this->getWithColumns() as $name => $column)
    {
      // if the column is on a related object property 
      // and if join() wasn't called previously on this object, do a simple join
      $peerClass = $column['peerClass'];
      if($peerClass && !in_array($peerClass, $this->relations))
      {
        list($column1, $column2) = $this->getRelation(str_replace('Peer', '', $peerClass));
        $c->addJoin($column1, $column2);
        $this->relations[]= $peerClass;
      }
      $c->addAsColumn($name, $column['column']);
    }
    
    return $c;
  }
  
  protected function relateObjects($new, $existingObjects, $isNew)
  {
    // brute force (to be optimized later)
    foreach ($existingObjects as $existingObject)
    {
      $methodName = 'add'.get_class($existingObject);
      if(method_exists($new, $methodName))
      {
        if($isNew)
        {
          call_user_func(array($new, 'init'.get_class($existingObject).'s'));
        }
        call_user_func(array($new, $methodName), $existingObject);
        break;
      }
    }
  }
  
  public function delete($con = null, $reinitCriteria = true)
  {
    $deleteCriteria = $this->getCriteria();
    if($deleteCriteria->equals(new Criteria()))
    {
      // delete will delete nothing when passed an empty criteria
      // while it should, in fact, delete all
      $fieldNames = call_user_func(array($this->getPeerClass(), 'getFieldNames'), BasePeer::TYPE_COLNAME);
      $firstFieldName = $fieldNames[0];
      $deleteCriteria->add($firstFieldName, true, Criteria::BINARY_OR);
    }
    $ret = call_user_func(array($this->getPeerClass(), 'doDelete'), $deleteCriteria, $con);
    $this->updateLatestQuery();
    if($reinitCriteria)
    {
      $this->reinitCriteria();
    }
    
    return $ret;
  }
  
  // Hydrating
  
  public function with($classes)
  {
    if(!is_array($classes))
    {
      $classes = func_get_args();
    }
    foreach($classes as $class)
    {
      $this->addWithClass($class);
    }
    
    return $this;
  }

  public function withColumn($column, $alias = null, $type = null)
  {
    $isCalculationColumn = strpos($column, '(') !== false;
    if(!$alias)
    {
      if($isCalculationColumn)
      {
        throw new Exception('Calculated colums added with withColumn() need an alias as second parameter');
      }
      else
      {
        $alias = $column;
      }
    }
    if($isCalculationColumn)
    {
      $peerClass = null;
    }
    else
    {
      list($peerClass, $columnName) = $this->getColName($column, null, true);
    }
    $this->withColumns [$alias]= array(
      'column'    => $isCalculationColumn ? $column : $columnName,
      'type'      => $type,
      'peerClass' => $peerClass
    );
    
    return $this;
  }
  
  // Finder Filters
  
  /**
   * Finder Fluid Interface for Criteria::setDistinct()
   */
  public function distinct()
  {
    $this->criteria->setDistinct();
    
    return $this;
  }
  
  /**
   * Finder Fluid Interface for Criteria::add()
   * Infers $column, $value, $comparison from $columnName and some optional arguments
   * Examples:
   *   $articleFinder->where('IsPublished')
   *    => $c->add(ArticlePeer::IS_PUBLISHED, true)
   *   $articleFinder->where('CommentId', 3)
   *    => $c->add(ArticlePeer::COMMENT_ID, 3)
   *   $articleFinder->where('Title', 'like', '%foo')
   *    => $c->add(ArticlePeer::TITLE, '%foo', Criteria::LIKE)
   *
   * @param      string  $columnName PHPName of the column bearing the condition
   * @param      array   $arguments  Optional array of arguments
   *
   * @return     sfPropelFinder the current finder object
   */
  public function where($columnName, $arguments = array())
  {
    $column = $this->getColName($columnName);
    if(!is_array($arguments))
    {
      $arguments = func_get_args();
      array_shift($arguments);
    } 
    list($value, $comparison) = $this->getValueAndComparisonFromArguments($arguments);

    $this->addCondition('and', $column, $value, $comparison );
    
    return $this;
  }

  /**
   * Finder Fluid Interface for Criteria::addAnd()
   * Infers $column, $value, $comparison from $columnName and some optional arguments
   * Examples:
   *   $articleFinder->_and('CommentId', 3)
   *    => $c->addAnd(ArticlePeer::COMMENT_ID, 3)
   *
   * @param      string  $columnName PHPName of the column bearing the condition
   * @param      array   $arguments  Optional array of arguments
   *
   * @return     sfPropelFinder the current finder object
   */
  public function _and($columnName, $arguments = array())
  {
    $column = $this->getColName($columnName);
    if(!is_array($arguments))
    {
      $arguments = func_get_args();
      array_shift($arguments);
    } 
    list($value, $comparison) = $this->getValueAndComparisonFromArguments($arguments);

    $this->addCondition('and', $column, $value, $comparison);
    
    return $this;
  }

  /**
   * Finder Fluid Interface for Criteria::addOr()
   * Infers $column, $value, $comparison from $columnName and some optional arguments
   * Examples:
   *   $articleFinder->_or('CommentId', 3)
   *    => $c->addOr(ArticlePeer::COMMENT_ID, 3)
   *
   * @param      string  $columnName PHPName of the column bearing the condition
   * @param      array   $arguments  Optional array of arguments
   *
   * @return     sfPropelFinder the current finder object
   */
  public function _or($columnName, $arguments = array())
  {
    $column = $this->getColName($columnName);
    if(!is_array($arguments))
    {
      $arguments = func_get_args();
      array_shift($arguments);
    } 
    list($value, $comparison) = $this->getValueAndComparisonFromArguments($arguments);
    $this->addCondition('or', $column, $value, $comparison);
    
    return $this;
  }

  /**
   * Conditions have to be stocked before being really used
   * cf. sfPropelFinder::buildCriteria()
   */
  protected function addCondition($cond, $column, $value, $comparison)
  {
    $criterion = $this->criteria->getNewCriterion($column, $value, $comparison);
    $criterion->func = "add".$cond;
    $this->criterions []= $criterion;
  }

  /**
   * We want that the Finder fuild Interface works like:
   *   PHP : whereA()->_andB->_orC()->_orD()->_andE()
   *   SQL : where A=? AND (B=? OR (C=? OR (D=? AND E=?)))
   * So we have to add condition starting by the last one!
   */
  protected function buildCriteria()
  {
    $criteria = clone $this->criteria;
    $criterions = $this->criterions;

    while ($criterion = array_pop($criterions))
    {
      if ($c = count($criterions))
      {
        call_user_func(array($criterions[$c-1], $criterion->func), $criterion);
      }
      else
      {
        call_user_func(array($criteria, $criterion->func), $criterion);
      }
    }
    
    return $criteria;
  }
  
  protected function getValueAndComparisonFromArguments($arguments = array())
  {
    $comparison = Criteria::EQUAL;
    switch (count($arguments))
    {
      case 0:
        $value = true;
        break;
      case 1:
        $value = array_shift($arguments);
        break;
      case 2:
        $comparison = array_shift($arguments);
        $comparisonUp = trim(strtoupper($comparison));
        if(in_array($comparisonUp, array('LIKE', 'NOT LIKE', 'ILIKE', 'NOT ILIKE', 'IN', 'NOT IN', 'IS NULL', 'IS NOT NULL')))
        {
          $comparison = ' '.$comparisonUp.' ';
        }
        $value = array_shift($arguments);
        break;
      default:
        throw new Exception('{sfPropelFinder} whereXXX can only be called with one or two arguments');
    }

    return array($value, $comparison);
  }
  
  /**
   * Finder fluid method to restrict results to a related object
   * Examples:
   *   $commentFinder->relatedTo($article)
   *    => $c->add(CommentPeer::ARTICLE_ID, $article->getId())
   */
  public function relatedTo($object)
  {
    $relatedObjectTableName = $object->getPeer()->getTableMap()->getName();
    foreach ($this->getColumnsForPeerClass($this->getPeerClass()) as $c)
    {
      if($c->getRelatedTableName() == $relatedObjectTableName)
      {
        $this->addCondition('and', $c->getFullyQualifiedName(), $object->getByName($c->getRelatedName(), BasePeer::TYPE_COLNAME), Criteria::EQUAL);
      }
    }
    
    return $this;
  }
  
  /**
   * Finder Fluid Interface for Criteria::addAscendingOrderByColumn()
   * and Criteria::addDescendingOrderByColumn()
   * Infers $column and $order from $columnName and some optional arguments
   * Examples:
   *   $articleFinder->orderBy('CreatedAt')
   *    => $c->addAscendingOrderByColumn(ArticlePeer::CREATED_AT)
   *   $articlefinder->orderBy('CategoryId', 'desc')
   *    => $c->addDescendingOrderByColumn(ArticlePeer::CATEGORY_ID)
   */
  public function orderBy($columnName, $arguments = array())
  {
    $column = $this->getColName($columnName);
    if(!is_array($arguments))
    {
      $arguments = func_get_args();
      array_shift($arguments);
    } 
    $order = strtoupper(array_shift($arguments));
    if(!$order)
    {
      $order = Criteria::ASC;
    }
    
    switch ($order)
    {
      case Criteria::ASC:
        $this->criteria->addAscendingOrderByColumn($column);
        break;
      case Criteria::DESC:
        $this->criteria->addDescendingOrderByColumn($column);
        break;
      default:
        throw new Exception('{sfPropelFinder} orderBy only accepts "asc" or "desc" as argument');
    }
    
    return $this;
  }
  
  /**
   * Finder Fluid Interface for Criteria::addJoin()
   * Infers $column1, $column2 and $operator from $relatedClass and some optional arguments
   * Uses the Propel column maps, based on the schema, to guess the related columns
   * Examples:
   *   $articleFinder->join('Comment')
   *    => $c->addJoin(ArticlePeer::ID, CommentPeer::ARTICLE_ID)
   *   $articleFinder->join('Category', 'RIGHT JOIN')
   *    => $c->addJoin(ArticlePeer::CATEGORY_ID, CategoryPeer::ID, Criteria::RIGHT_JOIN)
   */
  public function join($relatedClass, $arguments = array())
  {
    list($column1, $column2) = $this->getRelation($relatedClass);
    $this->relations[]= $relatedClass.'Peer';
    if(!is_array($arguments))
    {
      $arguments = func_get_args();
      array_shift($arguments);
    } 
    $operator = array_shift($arguments);
    if(!$operator)
    {
      $operator = null;
    }
    $this->criteria->addJoin($column1, $column2, $operator);
    
    return $this;
  }

  public function getRelation($phpName)
  {
    foreach($this->relations as $peerClass)
    {
      // try to find many to one or one to one relationship
      if($relation = $this->findRelation($phpName, $peerClass))
      {
        return $relation;
      }
      // try to find one to many relationship
      if($relation = $this->findRelation(str_replace('Peer', '', $peerClass), $phpName.'Peer'))
      {
        return array_reverse($relation);
      }
    }
    throw new Exception(sprintf('{sfPropelFinder} %s has no %s related table', $this->peerClass, $phpName));
  }
  
  protected function findRelation($phpName, $peerClass)
  {
    foreach ($this->getColumnsForPeerClass($peerClass) as $c)
    {
      if ($c->isForeignKey())
      {
        
        $related_tablename = $c ->getRelatedTableName();
        $compare_name = $phpName;
        
        if( $c -> getTable() -> getDatabaseMap() -> containsTable($related_tablename) ) {
            $table = $c -> getTable() -> getDatabaseMap() -> getTable($related_tablename);
            $compare_name = sfInflector::camelize($table -> getName());
        }
        
        if(sfInflector::camelize($c->getRelatedTableName()) == $compare_name)
        {
          return array(
            constant($peerClass.'::'.$c->getColumnName()),
            $c->getRelatedName()
          );
        }
      }
    }
    
    return false;
  }
  
  /**
   * Behavior-like supplementary getter for supplementary columns added by way of withColumn()
   * Requires symfony and sfMixer enabled
   */
  public function getColumn($object, $arguments)
  {
    $asName = 'WithColumn'.$arguments;

    return $object->$asName;
  }
  
  
  protected function getColumnsForPeerClass($peerClass)
  {
    if(class_exists($peerClass))
    {
      $tableMap = call_user_func(array($peerClass, 'getTableMap'));
      return $tableMap->getColumns();
    }
    return false;
  }
  
  protected function getColName($phpName, $peerClass = null, $withPeerClass = false)
  {
    if(array_key_exists($phpName, $this->withColumns))
    {
      return $phpName;
    }
    if(strpos($phpName, '_') !== false)
    {
      list($class, $phpName) = split('_', $phpName);
      $peerClass = $class.'Peer';
    }
    if(!$peerClass)
    {
      $peerClass = $this->peerClass;
    }
    try
    {
      $column = call_user_func(array($peerClass, 'translateFieldName'), $phpName, BasePeer::TYPE_PHPNAME, BasePeer::TYPE_COLNAME);
      return $withPeerClass ? array($peerClass, $column) : $column;
    }
    catch (PropelException $e)
    {
      throw new Exception(sprintf('{sfPropelFinder} %s has no %s column', $peerClass, $phpName));
    }
  }
  
  public function __call($name, $arguments)
  {
    if(strpos($name, 'where') === 0)
    {
      return $this->where(substr($name, 5), $arguments);
    }
    if(strpos($name, 'orderBy') === 0)
    {
      return $this->orderBy(substr($name, 7), $arguments);
    }
    if(strpos($name, 'join') === 0)
    {
      return $this->join(substr($name, 4), $arguments);
    }
    if(strpos($name, '_and') === 0)
    {
      return $this->_and(substr($name, 4), $arguments);
    }
    if(strpos($name, 'and') === 0)
    {
      return $this->_and(substr($name, 3), $arguments);
    }
    if(strpos($name, '_or') === 0)
    {
      return $this->_or(substr($name, 3), $arguments);
    }
    if(strpos($name, 'or') === 0)
    {
      return $this->_or(substr($name, 2), $arguments);
    }
    if(strpos($name, 'findBy') === 0)
    {
      array_unshift($arguments, substr($name, 6));
      return call_user_func_array(array($this, 'findBy'), $arguments);
    }
    if(strpos($name, 'findOneBy') === 0)
    {
      array_unshift($arguments, substr($name, 9));
      return call_user_func_array(array($this, 'findOneBy'), $arguments);
    }
    if(method_exists($this->criteria, $name))
    {
      call_user_func_array(array($this->criteria, $name), $arguments);
      return $this;
    }
    throw new Exception(sprintf('{sfPropelFinder} Undefined method %s', $name));
  }
}