PHP Selection::order方法代码示例

 static function appendSort(Nette\Database\Table\Selection &$query, $sort = NULL)
 {
     if (!is_null($sort)) {
         foreach ($sort as $k => $v) {
             if (Nette\Utils\Validators::isNumericInt($k)) {
                 $query->order($v);
             } else {
                 $query->order($k . ' ' . strtoupper($v));
             }
         }
     }
     return $query;
 }

 public function order($columns)
 {
     if (!$this->sqlBuilder->getOrder()) {
         // improve index utilization
         $this->sqlBuilder->addOrder("{$this->name}.{$this->column}" . (preg_match('~\\bDESC$~i', $columns) ? ' DESC' : ''));
     }
     return parent::order($columns);
 }

 /**
  * Adds ordering to specified column
  *
  * @param string column name
  * @param string one of ordering types
  * @return IDataSource (fluent)
  * @throws \Nette\InvalidArgumentException
  */
 public function sort($column, $order = IDataSource::ASCENDING)
 {
     if (!$this->hasColumn($column)) {
         throw new \Nette\InvalidArgumentException('Trying to sort data source by unknown column.');
     }
     $this->selection->order($this->mapping[$column] . ' ' . ($order === self::ASCENDING ? 'ASC' : 'DESC'));
     return $this;
 }

 /**
  * Pad:default.
  * @param int         $id
  * @param string|null $order
  * @throws BadRequestException
  */
 public function actionDefault($id, $order)
 {
     $this->loadPad($id);
     $this->notes = $this->noteManager->findByPad($id);
     if ($order) {
         $this->notes->order(OrderHelper::translateParameterToColumns($order));
     }
 }

 public function order($columns)
 {
     if (!$this->order) {
         // improve index utilization
         $this->order[] = "{$this->delimitedName}.{$this->delimitedColumn}" . (preg_match('~\\bDESC$~i', $columns) ? ' DESC' : '');
     }
     return parent::order($columns);
 }

 /**
  * API:
  *
  * <code>
  * $this->orderBy('column', EntityCollection::DESC); // ORDER BY [column] DESC
  * // or
  * $this->orderBy(array(
  *	'first'  => EntityCollection::ASC,
  *	'second' => EntityCollection::DESC,
  * ); // ORDER BY [first], [second] DESC
  * </code>
  *
  * @param  string|array $column
  * @param  bool $dir
  * @return EntityCollection
  */
 public function orderBy($column, $dir = NULL)
 {
     if (is_array($column)) {
         foreach ($column as $col => $d) {
             $this->orderBy($col, $d);
         }
     } else {
         $dir === NULL && ($dir = static::ASC);
         $this->selection->order($column . ($dir === static::DESC ? ' DESC' : ''));
     }
     $this->invalidate();
     return $this;
 }

 /**
  * Order data
  * @param  array  $sorting
  * @return self
  */
 public function sort(array $sorting)
 {
     if ($sorting) {
         $this->data_source->getSqlBuilder()->setOrder([], []);
         foreach ($sorting as $column => $sort) {
             $this->data_source->order("{$column} {$sort}");
         }
     } else {
         /**
          * Has the statement already a order by clause?
          */
         if (!$this->data_source->getSqlBuilder()->getOrder()) {
             $this->data_source->order($this->primary_key);
         }
     }
     return $this;
 }

 /**
  * Sort data
  * @param  Sorting $sorting
  * @return static
  */
 public function sort(Sorting $sorting)
 {
     if (is_callable($sorting->getSortCallback())) {
         call_user_func($sorting->getSortCallback(), $this->data_source, $sorting->getSort());
         return $this;
     }
     $sort = $sorting->getSort();
     if (!empty($sort)) {
         $this->data_source->getSqlBuilder()->setOrder([], []);
         foreach ($sort as $column => $order) {
             $this->data_source->order("{$column} {$order}");
         }
     } else {
         /**
          * Has the statement already a order by clause?
          */
         if (!$this->data_source->getSqlBuilder()->getOrder()) {
             $this->data_source->order($this->primary_key);
         }
     }
     return $this;
 }

 /**
  * @param array $sorting
  */
 public function sort(array $sorting)
 {
     foreach ($sorting as $column => $sort) {
         $this->selection->order("{$column} {$sort}");
     }
 }

 public function orderBy($row, $sorting = 'ASC')
 {
     return $this->nette_table->order($row . ' ' . $sorting);
 }

 function order($columns)
 {
     if (!$this->sqlBuilder->getOrder()) {
         $this->sqlBuilder->addOrder("{$this->name}.{$this->column}" . (preg_match('~\\bDESC\\z~i', $columns) ? ' DESC' : ''));
     }
     return parent::order($columns);
 }

 /**
  * @param \Nette\Database\Table\Selection $context
  * @return array
  */
 protected function orderAndFetch(Selection $context)
 {
     return $context->order('section.priority ASC, section.name ASC')->fetchPairs('id', 'name');
 }

 /**
  * Adds order clause, more calls appends to the end.
  * @param string $columns
  * @return self
  */
 public function order($columns)
 {
     $this->selection->order($columns);
     return $this;
 }

 function order($columns)
 {
     if (!$this->order) {
         $this->order[] = "{$this->delimitedName}.{$this->delimitedColumn}" . (preg_match('~\\bDESC$~i', $columns) ? ' DESC' : '');
     }
     return parent::order($columns);
 }

 public function orderBy($row, $sorting = 'ASC')
 {
     return $this->netteTable->order($this->prefixColumn($row) . ' ' . $sorting);
 }