/**
* 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: '******', 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));
}
/**
* @param \PDOStatement $statement
*
* @return \MongoDate
*/
protected function getMinimumValue(\PDOStatement $statement)
{
$result = $statement->fetchObject();
if (!isset($result) || !isset($result->minimum)) {
$date = new \DateTime($this->defaultValue);
} else {
$date = new \DateTime($result->minimum);
}
if ($this->timezone) {
$date->setTimezone(new \DateTimeZone($this->timezone));
}
return new \MongoDate($date->getTimestamp());
}
/**
* @param PDOStatement $query_result
*/
private function treat_success($query_result)
{
// Se o login e senha passado existem, inicia uma sessão, caso contrário, avisa o usuário.
if ($result_obj = $query_result->fetchObject()) {
// Define o nome no retorno
parent::set_result('name', $result_obj->name);
// Guarda o Id, para manter o login, e o Nome do usuário, para evitar uma consulta.
TSession::set_value('id_user', $result_obj->id);
TSession::set_value('name', $result_obj->name);
} else {
parent::set_error(1, "O par de usuário e senha não foi encontrado.");
}
}
/**
* Return the correct object back.
*
* @param PDOStatement $Statement
* @return mixed
* @author Justin Palmer
**/
public static function factory(PDOStatement $Statement, $set = false)
{
$count = $Statement->rowCount();
if ($set || $count > 1) {
return new ResultSet($Statement);
}
switch ($count) {
case 0:
throw new RecordNotFoundException($Statement->queryString);
case 1:
return $Statement->fetchObject('ResultRow');
}
}
/**
*
* @see Iterator::rewind()
*/
public function rewind()
{
//Dirty hack because rewind() is called before entering the loop
//and on object creation we already have query executed
if ($this->_needsRefresh) {
$this->_refresh();
} else {
$this->_needsRefresh = true;
}
$this->_currentRowObj = $this->_statement->fetchObject('\\phpSweetPDO\\RecordsetRow');
if ($this->_statement->errorCode() !== '00000') {
throw new DbException($this->_statement->errorInfo(), $this->_statement->queryString);
}
}
/**
* Get results
* @return array
*/
public function get_results()
{
if (!empty($this->fetched_rows)) {
return $this->fetched_rows;
}
$this->fetched_rows = array();
if (!empty($this->result) && $this->result->rowCount() > 0) {
try {
while ($row = $this->result->fetchObject()) {
$this->fetched_rows[] = $row;
}
} catch (Exception $e) {
}
}
return $this->fetched_rows;
}
/**
* Fetches one row and returns it as an object of class $class_name. Some notes:
* 1) The class constuctor WILL BE CALLED.
* 2) If the variable is set in the constructor, it will overwrite whatever
* is pulled from the database.
*
* @param string $class_name Name of class to instantiate.
* @param array $args Array of elements passed to constructor.
* @return object
*/
public function fetchObject($class_name, array $args = null)
{
$this->checkStatement();
// PDO's fetchObject second parameter is type hinted so you can't
// pass null to it without receiving a warning. This is why we have
// to check and have a separate call.
if (isset($args)) {
$result = $this->pdo_statement->fetchObject($class_name, $args);
} else {
$result = $this->pdo_statement->fetchObject($class_name);
}
if (empty($result)) {
$this->clearStatement();
}
return $result;
}
/**
* iterates over a result object and calls $callback for each row in the result
* @param \PDOStatement|mixed $result result object with a fetchObject() method
* @param callable $callback
* @return array
*/
protected function autoIterate($result, $callback)
{
$data = [];
while ($row = $result->fetchObject()) {
$callback($data, $row);
}
return $data;
}
/**
* Returns an array of object rows based on the last prepare/execute
*
* @param PDOStatement $sth
* @param string $type the type of objects to be returned
* @return array an array of object rows
*/
public function getResultObjects(PDOStatement $sth, $class = 'stdClass')
{
$output = array();
while (($o = $sth->fetchObject($class)) !== false) {
array_push($output, $o);
}
return $output;
}
public function fetchObject($class = 'StdClass', $options = NULL)
{
if ($this->dbh->cache && $this->cachedData) {
$data = current($this->cachedData);
next($this->cachedData);
$obj = new $class();
foreach ($data as $key => $val) {
$obj->{$key} = $val;
}
if (method_exists($obj, '__wakeup')) {
$obj->__wakeup();
}
return $obj;
} else {
return parent::fetchObject($class, $options);
}
}
/**
* Overwrite. Fixes HHVM strict issue.
*/
public function fetchObject($class_name = "stdClass", $ctor_args = null)
{
return parent::fetchObject($class_name, $ctor_args);
}
/**
* 获取对象返回
*
* @access public
* @param string $class_name 创建类名
* @return object $object 数据对象
*/
public function fetch_object($class_name = 'stdClass')
{
return parent::fetchObject($class_name);
}
/**
* Método criado para o agrupamento de valores de um tipo especifico, como algumas tabelas não possuem uma chave primária definida, não é possível usar o recurso do PDO que é semelhente ao desta função
* @param PDOStatement $prepare O resultado de uma consulta
* @param string|array $colunaChave O nome da coluna que servira de chave para o agrupamento
* @return array Um array com os valores agrupados de acorod com a coluna informada
*/
public function agruparPDOStatement(PDOStatement $prepare, $colunaChave)
{
if (!is_string($colunaChave)) {
throw new Exception("Invalid value: a coluna informada é inválida");
}
$arrayRet = array();
while ($row = $prepare->fetchObject()) {
if (is_string($colunaChave)) {
$arrayRet[$row->{$colunaChave}][] = $row;
} elseif (is_array($colunaChave)) {
foreach ($colunaChave as $chave) {
$arrayRet[$row->{$value}][] = $row;
}
} else {
throw new Exception("Ivalid value: o nome da chave é inválido");
}
}
return $arrayRet;
}
/**
* Returns the first row as an object
* @param PDOStatement $ps
* @param str $obj
* @return array numbered keys, with Objects
*/
protected final function getDataRowsAsObjects($ps, $obj)
{
$data = array();
while ($row = $ps->fetchObject($obj)) {
$data[] = $row;
}
$ps->closeCursor();
return $data;
}
/**
* @param \PDOStatement $res
* @param string $class
* @return mixed
*/
public static function fetch($res, $class = 'stdClass')
{
if ($class != null) {
return $res->fetchObject($class);
} else {
return $res->fetch(\PDO::FETCH_ASSOC);
}
}
/**
* Une methode fetch qui retourne un tableau d'objets de la classe courante
* @param PDOStatement $s
*/
public static function fetch(\PDOStatement $s)
{
$class = get_called_class();
$lines = array();
while ($line = $s->fetchObject($class)) {
$lines[] = $line;
}
return $lines;
}
