 PHP Page 2 - Coding Examples of the Iterator, Countable and ArrayAccess SPL Interfaces in PHP 5 |
| PHP Page 2 - Coding Examples of the Iterator, Countable and ArrayAccess SPL Interfaces in PHP 5 |
Review: the MySQLiWrapper and MySQLi_ResultWrapper classes - PHPWelcome to the final installment of a series that provides an overview of the Iterator, Countable and ArrayAccess SPL interfaces in PHP 5. Made up of six parts, this series teaches you how to build a fully-working MySQL abstraction class that takes advantage of the methods inherited from these native interfaces to manipulate database record sets easily by using an array syntax.
print this article SEARCH DEV SHED |
Before I start coding some sample scripts that show how to work with the implementing “MySQLi_ResultWrapper” class, I'd like to reintroduce its definition, just in case you haven’t had the chance to study it in depth. So, here’s how this class was developed: class MySQLiWrapper extends MySQLi {
private static $_instance = NULL;
// return Singleton instance of MySQL class public static function getInstance(array $config = array()) { if (self::$_instance === NULL) { self::$_instance = new self($config); } return self::$_instance; }
// private constructor private function __construct(array $config) { if (count($config) < 4) { throw new Exception('Invalid number of connection parameters'); } list($host, $user, $password, $database) = $config; parent::__construct($host, $user, $password, $database); if ($this->connect_error) { throw new Exception('Error connecting to MySQL : ' . $this->connect_errno . ' ' . $this->connect_error); } }
// prevent cloning class instance private function __clone(){}
// perform query public function runQuery($query) { if (is_string($query) AND !empty($query)) { if ((!$this->real_query($query))) { throw new Exception('Error performing query ' . $query . ' - Error message : ' . $this->error); } return new MySQLi_ResultWrapper($this); } }
// get insertion ID public function getInsertID() { return $this->insert_id; }
// close database connection public function __destruct() { $this->close(); } } Since this class has been discussed in previous part of the series, I’m not going to waste your time (and mine) explaining how it works. Instead, I suggest you pay attention to the class below, which is an implementer of the Iterator, Countable and ArrayAccess SPL interfaces mentioned in the introduction: class MySQLi_ResultWrapper extends MySQLi_Result implements Iterator, ArrayAccess, Countable { private $_pointer = 0;
// fetch row as an object public function fetchObject() { if (!$row = $this->fetch_object()) { return NULL; } return $row; }
// fetch row as an associative array public function fetchAssocArray() { if (!$row = $this->fetch_assoc()) { return NULL; } return $row; }
// fetch row as an enumerated array public function fetchNumArray() { if (!$row = $this->fetch_row()) { return NULL; } return $row; }
// fetch all rows public function fetchAll($type = MYSQLI_ASSOC) { if ($type !== MYSQLI_ASSOC AND $type !== MYSQLI_NUM AND $type !== MYSQLI_BOTH) { $type = MYSQLI_ASSOC; } if (!$rows = $this->fetch_all($type)) { return NULL; } return $rows; }
// get definition information on fields public function fetchFieldsInfo() { if (!$fieldsInfo = $this->fetch_fields()) { throw new Exception('No information available for table fields.'); } return $fieldsInfo; }
// get definition information on next field public function fetchFieldInfo() { if (!$fieldInfo = $this->fetch_field()) { throw new Exception('No information available for current table field.'); } return $fieldInfo; }
// move pointer in result set to specified offset public function movePointer($offset) { $offset = abs((int)$offset); $limit = $this->num_rows - 1; if ($limit <= 0 OR $offset > $limit) { return NULL; } unset($limit); return $this->data_seek($offset); }
// count rows in result set (implementation required by 'count()' method in Countable interface) public function count() { return $this->num_rows; }
// reset result set pointer (implementation required by 'rewind()' method in Iterator interface) public function rewind() { $this->_pointer = 0; $this->movePointer($this->_pointer); return $this; }
// get current row set in result set (implementation required by 'current()' method in Iterator interface) public function current() { if (!$this->valid()) { throw new Exception('Unable to retrieve current row.'); } $this->movePointer($this->_pointer); return $this->fetchObject(); }
// get current result set pointer (implementation required by 'key()' method in Iterator interface) public function key() { return $this->_pointer; }
// move forward result set pointer (implementation required by 'next()' method in Iterator interface) public function next() { ++$this->_pointer; $this->movePointer($this->_pointer); return $this; }
// determine if result set pointer is valid or not (implementation required by 'valid()' method in Iterator interface) public function valid() { return $this->_pointer < $this->num_rows; }
// determine if the given offset exists (implementation required by 'offsetExists()' method in ArrayAccess interface) public function offsetExists($offset) { $this->movePointer($offset); $row = $this->fetchObject(); return isset($row); }
// get row according to given offset (implementation required by 'offsetExists()' method in ArrayAccess interface) public function offsetGet($offset) { $this->_pointer = abs((int)$offset); return $this->current(); }
// not implemented (required by 'offsetSet()' method in ArrayAccess interface) public function offsetSet($offset, $value){}
// not implemented (required by 'offsetUnset()' method in ArrayAccess interface) public function offsetUnset($offset){}
// free up result set public function __destruct() { $this->close(); } } While the definition of the above “MySQLi_ResultWrapper” class is somewhat long, it is easy to follow, since most of its methods are inherited from the Iterator, Countable and ArrayAccess native interfaces. At this point, you’ll surely be wondering what this buys us. Well, as I explained in the introduction, thanks to this inheritance, the class can be used to manipulate MySQL data sets as if they were plain PHP arrays. To demonstrate this, though, it’s necessary to code some scripts that show the veracity of this claim. Therefore, in the following segment I’m going to write an example that will show how to utilize an instance of the “MySQLi_ResultWrapper” class to traverse a simple database result set. To learn how this example will be coded, click on the link below and keep reading.
blog comments powered by Disqus |
|
|
|
|
|
|
|
