PHP Criteria::getAsColumns方法代码示例

 /**
  * Ensures uniqueness of select column names by turning them all into aliases
  * This is necessary for queries on more than one table when the tables share a column name
  *
  * @see http://propel.phpdb.org/trac/ticket/795
  *
  * @param  Criteria $criteria
  * @return Criteria The input, with Select columns replaced by aliases
  */
 public function turnSelectColumnsToAliases(Criteria $criteria)
 {
     $selectColumns = $criteria->getSelectColumns();
     // clearSelectColumns also clears the aliases, so get them too
     $asColumns = $criteria->getAsColumns();
     $criteria->clearSelectColumns();
     $columnAliases = $asColumns;
     // add the select columns back
     foreach ($selectColumns as $clause) {
         // Generate a unique alias
         $baseAlias = preg_replace('/\\W/', '_', $clause);
         $alias = $baseAlias;
         // If it already exists, add a unique suffix
         $i = 0;
         while (isset($columnAliases[$alias])) {
             $i++;
             $alias = $baseAlias . '_' . $i;
         }
         // Add it as an alias
         $criteria->addAsColumn($alias, $clause);
         $columnAliases[$alias] = $clause;
     }
     // Add the aliases back, don't modify them
     foreach ($asColumns as $name => $clause) {
         $criteria->addAsColumn($name, $clause);
     }
     return $criteria;
 }

 /**
  * Add the content of a Criteria to the current Criteria
  * In case of conflict, the current Criteria keeps its properties
  *
  * @param Criteria $criteria The criteria to read properties from
  * @param string   $operator The logical operator used to combine conditions
  *                           Defaults to Criteria::LOGICAL_AND, also accepts Criteria::LOGICAL_OR
  *                           This parameter is deprecated, use _or() instead
  *
  * @return $this|Criteria The current criteria object
  */
 public function mergeWith(Criteria $criteria, $operator = null)
 {
     // merge limit
     $limit = $criteria->getLimit();
     if (0 != $limit && -1 === $this->getLimit()) {
         $this->limit = $limit;
     }
     // merge offset
     $offset = $criteria->getOffset();
     if (0 != $offset && 0 === $this->getOffset()) {
         $this->offset = $offset;
     }
     // merge select modifiers
     $selectModifiers = $criteria->getSelectModifiers();
     if ($selectModifiers && !$this->selectModifiers) {
         $this->selectModifiers = $selectModifiers;
     }
     // merge select columns
     $this->selectColumns = array_merge($this->getSelectColumns(), $criteria->getSelectColumns());
     // merge as columns
     $commonAsColumns = array_intersect_key($this->getAsColumns(), $criteria->getAsColumns());
     if (!empty($commonAsColumns)) {
         throw new LogicException('The given criteria contains an AsColumn with an alias already existing in the current object');
     }
     $this->asColumns = array_merge($this->getAsColumns(), $criteria->getAsColumns());
     // merge orderByColumns
     $orderByColumns = array_merge($this->getOrderByColumns(), $criteria->getOrderByColumns());
     $this->orderByColumns = array_unique($orderByColumns);
     // merge groupByColumns
     $groupByColumns = array_merge($this->getGroupByColumns(), $criteria->getGroupByColumns());
     $this->groupByColumns = array_unique($groupByColumns);
     // merge where conditions
     if (Criteria::LOGICAL_OR === $operator) {
         $this->_or();
     }
     $isFirstCondition = true;
     foreach ($criteria->getMap() as $key => $criterion) {
         if ($isFirstCondition && Criteria::LOGICAL_OR === $this->defaultCombineOperator) {
             $this->addOr($criterion, null, null, false);
             $this->defaultCombineOperator = Criteria::LOGICAL_AND;
         } elseif ($this->containsKey($key)) {
             $this->addAnd($criterion);
         } else {
             $this->add($criterion);
         }
         $isFirstCondition = false;
     }
     // merge having
     $having = $criteria->getHaving();
     if ($having) {
         if ($this->getHaving()) {
             $this->addHaving($this->getHaving()->addAnd($having));
         } else {
             $this->addHaving($having);
         }
     }
     // merge alias
     $commonAliases = array_intersect_key($this->getAliases(), $criteria->getAliases());
     if (!empty($commonAliases)) {
         throw new LogicException('The given criteria contains an alias already existing in the current object');
     }
     $this->aliases = array_merge($this->getAliases(), $criteria->getAliases());
     // merge join
     $this->joins = array_merge($this->getJoins(), $criteria->getJoins());
     return $this;
 }

 public function testMergeWithAsColumns()
 {
     $c1 = new Criteria();
     $c1->addAsColumn('foo', BookTableMap::COL_TITLE);
     $c1->addAsColumn('bar', BookTableMap::COL_ID);
     $c2 = new Criteria();
     $c1->mergeWith($c2);
     $this->assertEquals(array('foo' => BookTableMap::COL_TITLE, 'bar' => BookTableMap::COL_ID), $c1->getAsColumns(), 'mergeWith() does not remove an existing as columns');
     $c1 = new Criteria();
     $c2 = new Criteria();
     $c2->addAsColumn('foo', BookTableMap::COL_TITLE);
     $c2->addAsColumn('bar', BookTableMap::COL_ID);
     $c1->mergeWith($c2);
     $this->assertEquals(array('foo' => BookTableMap::COL_TITLE, 'bar' => BookTableMap::COL_ID), $c1->getAsColumns(), 'mergeWith() merges the select columns to an empty as');
     $c1 = new Criteria();
     $c1->addAsColumn('foo', BookTableMap::COL_TITLE);
     $c2 = new Criteria();
     $c2->addAsColumn('bar', BookTableMap::COL_ID);
     $c1->mergeWith($c2);
     $this->assertEquals(array('foo' => BookTableMap::COL_TITLE, 'bar' => BookTableMap::COL_ID), $c1->getAsColumns(), 'mergeWith() merges the select columns after the existing as columns');
 }