PHP PDOStatement::fetchObject方法代码示例

 /**
  * Fetch next result
  * 
  * @param boolean|string $object Fetch as object
  * @return \stdClass
  */
 public function next($object = TRUE)
 {
     if ($object) {
         if ($object === TRUE) {
             return $this->stmt->fetchObject();
         }
         return $this->stmt->fetchObject($object);
     }
     return $this->stmt->fetch(\PDO::FETCH_ASSOC);
 }

 public function fetch($class = null)
 {
     if (!$this->result) {
         throw new Exception('Can\'t fetch result if no query!');
     }
     return $class === false ? $this->result->fetch(PDO::FETCH_ASSOC) : $this->result->fetchObject($class ?: self::config('fetch'));
 }

 /**
  * {@inheritdoc}
  *
  * @throws \Orno\Db\Exception\NoResourceException
  */
 public function fetchObject()
 {
     if (!$this->statement instanceof \PDOStatement) {
         throw new Exception\NoResourceException(sprintf('%s expects a query to have been prepared and executed', __METHOD__));
     }
     return $this->statement->fetchObject();
 }

 /**
  * @param \PDOStatement $statement
  *
  * @return \MongoId
  */
 protected function getMinimumValue(\PDOStatement $statement)
 {
     $result = $statement->fetchObject();
     if (!isset($result) || !isset($result->minimum)) {
         return;
     }
     return new \MongoId($result->minimum);
 }

 /**
  * 获得结果集中的下一行，同时根据设置的类返回如果没有设置则返回的使StdClass对象
  * 
  * @param string $className  使用的类
  * @param array $ctor_args   初始化参数
  * @return object
  */
 public function fetchObject($className = '', $ctor_args = array())
 {
     if ($className === '') {
         return $this->_statement->fetchObject();
     } else {
         return $this->_statement->fetchObject($className, $ctor_args);
     }
 }

 /** @param PDOStatement $query_result */
 private function treat_success($query_result)
 {
     $result_array = array();
     while ($query_obj = $query_result->fetchObject()) {
         $result_array[] = $query_obj;
     }
     parent::set_result('result_array', $result_array);
 }

 protected static function fetch(\PDOStatement $result)
 {
     $out = array();
     while ($record = $result->fetchObject(get_called_class())) {
         $out[] = $record;
     }
     return $out;
 }

 /**
  * @param \PDOStatement $statement
  *
  * @return mixed $value
  */
 protected function getMinimumValue(\PDOStatement $statement)
 {
     $result = $statement->fetchObject();
     if (!isset($result) || !isset($result->minimum)) {
         return $this->defaultValue;
     }
     return $result->minimum;
 }

 /**
  * Return the current rowset as an object with columns set as members of the object.
  *
  * @param string $className OPTIONAL: The class of the object returned,
  *                          defaults to 'stdClass'
  * @param array $args       OPTIONAL: Arguments to pass the the class constructor.
  * @return object
  */
 public function fetchObject($className = 'stdClass', $args = array())
 {
     try {
         return $this->_stmt->fetchObject($className, $args);
     } catch (PDOException $e) {
         throw new DBALite_Exception("Error fetching row from result set", $e);
     }
 }

 function fetch(PDOStatement $result, $result_type = Database::FETCH_ASSOC, $className = "stdClass", $classArgs = null)
 {
     if ($result_type == self::FETCH_CLASS) {
         $row = $result->fetchObject($className, $classArgs);
     } else {
         $row = $result->fetch($result_type);
     }
     return $row;
 }

 /**
  * Returns query result as an object based on the name of the called class.
  *
  * @param PDOStatement $q
  *
  * @return Model $object 
  */
 private static function asObject($q, $getFkAsObject)
 {
     while ($object = $q->fetchObject(get_called_class())) {
         if ($getFkAsObject) {
             self::getFkAsObject($object);
         }
         return $object;
     }
 }

 /**
  * Fetches the next row and returns it as an object.
  *
  * @param string $class  OPTIONAL Name of the class to create.
  * @param array  $config OPTIONAL Constructor arguments for the class.
  * @return mixed One object instance of the specified class.
  * @throws Zend_Db_Statement_Exception
  */
 public function fetchObject($class = 'stdClass', array $config = array())
 {
     try {
         return $this->_stmt->fetchObject($class, $config);
     } catch (PDOException $e) {
         require_once 'Zend/Db/Statement/Exception.php';
         throw new Zend_Db_Statement_Exception($e->getMessage());
     }
 }

 /**
  * Executes statement and returns result as DataObject
  *
  * @return DataObject
  */
 public function single()
 {
     $this->execute();
     $data = $this->stmt->fetchObject('\\Core\\Data\\DataObject');
     if (!empty($data)) {
         $data = $this->executeCallbackAndSchemeHandler($data);
     }
     return $data;
 }

 /**
  * Returns information about a definition.
  *
  * @param string $term Term about which to return information
  *
  * @return void
  */
 public function onCommandLartinfo($term)
 {
     $this->select->execute(array(':name' => $term));
     $row = $this->select->fetchObject();
     $msg = $this->getEvent()->getNick() . ': ';
     if (!$row) {
         $msg .= 'Lart not found';
     } else {
         $msg .= 'Term: ' . $row->name . ', Definition: ' . $row->definition . ', User: ' . $row->hostmask . ', Added: ' . date('n/j/y g:i A', $row->tstamp);
     }
     $this->doNotice($this->getEvent()->getSource(), $msg);
 }

 /**
  * @param \PDOStatement $statement
  *
  * @return \MongoDate
  */
 protected function getMinimumValue(\PDOStatement $statement)
 {
     $result = $statement->fetchObject();
     if (!isset($result) || !isset($result->minimum)) {
         return new \MongoDate(strtotime($this->defaultValue));
     }
     if ($this->timezone) {
         $date = $result->minimum . ' ' . $this->timezone;
     } else {
         $date = $result->minimum;
     }
     return new \MongoDate(strtotime($date));
 }