interface/modules/zend_modules/library/Zend/Db/TableGateway/AbstractTableGateway.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2013 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9
  10 namespace Zend\Db\TableGateway;
  11
  12 use Zend\Db\Adapter\AdapterInterface;
  13 use Zend\Db\ResultSet\ResultSet;
  14 use Zend\Db\ResultSet\ResultSetInterface;
  15 use Zend\Db\Sql\Delete;
  16 use Zend\Db\Sql\Insert;
  17 use Zend\Db\Sql\Select;
  18 use Zend\Db\Sql\Sql;
  19 use Zend\Db\Sql\TableIdentifier;
  20 use Zend\Db\Sql\Update;
  21 use Zend\Db\Sql\Where;
  22
  23 /**
  24  *
  25  * @property AdapterInterface $adapter
  26  * @property int $lastInsertValue
  27  * @property string $table
  28  */
  29 abstract class AbstractTableGateway implements TableGatewayInterface
  30 {
  31
  32     /**
  33      * @var bool
  34      */
  35     protected $isInitialized = false;
  36
  37     /**
  38      * @var AdapterInterface
  39      */
  40     protected $adapter = null;
  41
  42     /**
  43      * @var string
  44      */
  45     protected $table = null;
  46
  47     /**
  48      * @var array
  49      */
  50     protected $columns = array();
  51
  52     /**
  53      * @var Feature\FeatureSet
  54      */
  55     protected $featureSet = null;
  56
  57     /**
  58      * @var ResultSetInterface
  59      */
  60     protected $resultSetPrototype = null;
  61
  62     /**
  63      * @var Sql
  64      */
  65     protected $sql = null;
  66
  67     /**
  68      *
  69      * @var int
  70      */
  71     protected $lastInsertValue = null;
  72
  73     /**
  74      * @return bool
  75      */
  76     public function isInitialized()
  77     {
  78         return $this->isInitialized;
  79     }
  80
  81     /**
  82      * Initialize
  83      *
  84      * @throws Exception\RuntimeException
  85      * @return null
  86      */
  87     public function initialize()
  88     {
  89         if ($this->isInitialized) {
  90             return;
  91         }
  92
  93         if (!$this->featureSet instanceof Feature\FeatureSet) {
  94             $this->featureSet = new Feature\FeatureSet;
  95         }
  96
  97         $this->featureSet->setTableGateway($this);
  98         $this->featureSet->apply('preInitialize', array());
  99
 100         if (!$this->adapter instanceof AdapterInterface) {
 101             throw new Exception\RuntimeException('This table does not have an Adapter setup');
 102         }
 103
 104         if (!is_string($this->table) && !$this->table instanceof TableIdentifier) {
 105             throw new Exception\RuntimeException('This table object does not have a valid table set.');
 106         }
 107
 108         if (!$this->resultSetPrototype instanceof ResultSetInterface) {
 109             $this->resultSetPrototype = new ResultSet;
 110         }
 111
 112         if (!$this->sql instanceof Sql) {
 113             $this->sql = new Sql($this->adapter, $this->table);
 114         }
 115
 116         $this->featureSet->apply('postInitialize', array());
 117
 118         $this->isInitialized = true;
 119     }
 120
 121     /**
 122      * Get table name
 123      *
 124      * @return string
 125      */
 126     public function getTable()
 127     {
 128         return $this->table;
 129     }
 130
 131     /**
 132      * Get adapter
 133      *
 134      * @return AdapterInterface
 135      */
 136     public function getAdapter()
 137     {
 138         return $this->adapter;
 139     }
 140
 141     /**
 142      * @return array
 143      */
 144     public function getColumns()
 145     {
 146         return $this->columns;
 147     }
 148
 149     /**
 150      * @return Feature\FeatureSet
 151      */
 152     public function getFeatureSet()
 153     {
 154         return $this->featureSet;
 155     }
 156
 157     /**
 158      * Get select result prototype
 159      *
 160      * @return ResultSet
 161      */
 162     public function getResultSetPrototype()
 163     {
 164         return $this->resultSetPrototype;
 165     }
 166
 167     /**
 168      * @return Sql
 169      */
 170     public function getSql()
 171     {
 172         return $this->sql;
 173     }
 174
 175     /**
 176      * Select
 177      *
 178      * @param Where|\Closure|string|array $where
 179      * @return ResultSet
 180      */
 181     public function select($where = null)
 182     {
 183         if (!$this->isInitialized) {
 184             $this->initialize();
 185         }
 186
 187         $select = $this->sql->select();
 188
 189         if ($where instanceof \Closure) {
 190             $where($select);
 191         } elseif ($where !== null) {
 192             $select->where($where);
 193         }
 194
 195         return $this->selectWith($select);
 196     }
 197
 198     /**
 199      * @param Select $select
 200      * @return null|ResultSetInterface
 201      * @throws \RuntimeException
 202      */
 203     public function selectWith(Select $select)
 204     {
 205         if (!$this->isInitialized) {
 206             $this->initialize();
 207         }
 208         return $this->executeSelect($select);
 209     }
 210
 211     /**
 212      * @param Select $select
 213      * @return ResultSet
 214      * @throws Exception\RuntimeException
 215      */
 216     protected function executeSelect(Select $select)
 217     {
 218         $selectState = $select->getRawState();
 219         if ($selectState['table'] != $this->table) {
 220             throw new Exception\RuntimeException('The table name of the provided select object must match that of the table');
 221         }
 222
 223         if ($selectState['columns'] == array(Select::SQL_STAR)
 224             && $this->columns !== array()) {
 225             $select->columns($this->columns);
 226         }
 227
 228         // apply preSelect features
 229         $this->featureSet->apply('preSelect', array($select));
 230
 231         // prepare and execute
 232         $statement = $this->sql->prepareStatementForSqlObject($select);
 233         $result = $statement->execute();
 234
 235         // build result set
 236         $resultSet = clone $this->resultSetPrototype;
 237         $resultSet->initialize($result);
 238
 239         // apply postSelect features
 240         $this->featureSet->apply('postSelect', array($statement, $result, $resultSet));
 241
 242         return $resultSet;
 243     }
 244
 245     /**
 246      * Insert
 247      *
 248      * @param  array $set
 249      * @return int
 250      */
 251     public function insert($set)
 252     {
 253         if (!$this->isInitialized) {
 254             $this->initialize();
 255         }
 256         $insert = $this->sql->insert();
 257         $insert->values($set);
 258         return $this->executeInsert($insert);
 259     }
 260
 261     /**
 262      * @param Insert $insert
 263      * @return mixed
 264      */
 265     public function insertWith(Insert $insert)
 266     {
 267         if (!$this->isInitialized) {
 268             $this->initialize();
 269         }
 270         return $this->executeInsert($insert);
 271     }
 272
 273     /**
 274      * @todo add $columns support
 275      *
 276      * @param Insert $insert
 277      * @return mixed
 278      * @throws Exception\RuntimeException
 279      */
 280     protected function executeInsert(Insert $insert)
 281     {
 282         $insertState = $insert->getRawState();
 283         if ($insertState['table'] != $this->table) {
 284             throw new Exception\RuntimeException('The table name of the provided Insert object must match that of the table');
 285         }
 286
 287         // apply preInsert features
 288         $this->featureSet->apply('preInsert', array($insert));
 289
 290         $statement = $this->sql->prepareStatementForSqlObject($insert);
 291         $result = $statement->execute();
 292         $this->lastInsertValue = $this->adapter->getDriver()->getConnection()->getLastGeneratedValue();
 293
 294         // apply postInsert features
 295         $this->featureSet->apply('postInsert', array($statement, $result));
 296
 297         return $result->getAffectedRows();
 298     }
 299
 300     /**
 301      * Update
 302      *
 303      * @param  array $set
 304      * @param  string|array|closure $where
 305      * @return int
 306      */
 307     public function update($set, $where = null)
 308     {
 309         if (!$this->isInitialized) {
 310             $this->initialize();
 311         }
 312         $sql = $this->sql;
 313         $update = $sql->update();
 314         $update->set($set);
 315         if ($where !== null) {
 316             $update->where($where);
 317         }
 318         return $this->executeUpdate($update);
 319     }
 320
 321     /**
 322      * @param \Zend\Db\Sql\Update $update
 323      * @return mixed
 324      */
 325     public function updateWith(Update $update)
 326     {
 327         if (!$this->isInitialized) {
 328             $this->initialize();
 329         }
 330         return $this->executeUpdate($update);
 331     }
 332
 333     /**
 334      * @todo add $columns support
 335      *
 336      * @param Update $update
 337      * @return mixed
 338      * @throws Exception\RuntimeException
 339      */
 340     protected function executeUpdate(Update $update)
 341     {
 342         $updateState = $update->getRawState();
 343         if ($updateState['table'] != $this->table) {
 344             throw new Exception\RuntimeException('The table name of the provided Update object must match that of the table');
 345         }
 346
 347         // apply preUpdate features
 348         $this->featureSet->apply('preUpdate', array($update));
 349
 350         $statement = $this->sql->prepareStatementForSqlObject($update);
 351         $result = $statement->execute();
 352
 353         // apply postUpdate features
 354         $this->featureSet->apply('postUpdate', array($statement, $result));
 355
 356         return $result->getAffectedRows();
 357     }
 358
 359     /**
 360      * Delete
 361      *
 362      * @param  Where|\Closure|string|array $where
 363      * @return int
 364      */
 365     public function delete($where)
 366     {
 367         if (!$this->isInitialized) {
 368             $this->initialize();
 369         }
 370         $delete = $this->sql->delete();
 371         if ($where instanceof \Closure) {
 372             $where($delete);
 373         } else {
 374             $delete->where($where);
 375         }
 376         return $this->executeDelete($delete);
 377     }
 378
 379     /**
 380      * @param Delete $delete
 381      * @return mixed
 382      */
 383     public function deleteWith(Delete $delete)
 384     {
 385         $this->initialize();
 386         return $this->executeDelete($delete);
 387     }
 388
 389     /**
 390      * @todo add $columns support
 391      *
 392      * @param Delete $delete
 393      * @return mixed
 394      * @throws Exception\RuntimeException
 395      */
 396     protected function executeDelete(Delete $delete)
 397     {
 398         $deleteState = $delete->getRawState();
 399         if ($deleteState['table'] != $this->table) {
 400             throw new Exception\RuntimeException('The table name of the provided Update object must match that of the table');
 401         }
 402
 403         // pre delete update
 404         $this->featureSet->apply('preDelete', array($delete));
 405
 406         $statement = $this->sql->prepareStatementForSqlObject($delete);
 407         $result = $statement->execute();
 408
 409         // apply postDelete features
 410         $this->featureSet->apply('postDelete', array($statement, $result));
 411
 412         return $result->getAffectedRows();
 413     }
 414
 415     /**
 416      * Get last insert value
 417      *
 418      * @return int
 419      */
 420     public function getLastInsertValue()
 421     {
 422         return $this->lastInsertValue;
 423     }
 424
 425     /**
 426      * __get
 427      *
 428      * @param  string $property
 429      * @throws Exception\InvalidArgumentException
 430      * @return mixed
 431      */
 432     public function __get($property)
 433     {
 434         switch (strtolower($property)) {
 435             case 'lastinsertvalue':
 436                 return $this->lastInsertValue;
 437             case 'adapter':
 438                 return $this->adapter;
 439             case 'table':
 440                 return $this->table;
 441         }
 442         if ($this->featureSet->canCallMagicGet($property)) {
 443             return $this->featureSet->callMagicGet($property);
 444         }
 445         throw new Exception\InvalidArgumentException('Invalid magic property access in ' . __CLASS__ . '::__get()');
 446     }
 447
 448     /**
 449      * @param string $property
 450      * @param mixed $value
 451      * @return mixed
 452      * @throws Exception\InvalidArgumentException
 453      */
 454     public function __set($property, $value)
 455     {
 456         if ($this->featureSet->canCallMagicSet($property)) {
 457             return $this->featureSet->callMagicSet($property, $value);
 458         }
 459         throw new Exception\InvalidArgumentException('Invalid magic property access in ' . __CLASS__ . '::__set()');
 460     }
 461
 462     /**
 463      * @param $method
 464      * @param $arguments
 465      * @return mixed
 466      * @throws Exception\InvalidArgumentException
 467      */
 468     public function __call($method, $arguments)
 469     {
 470         if ($this->featureSet->canCallMagicCall($method)) {
 471             return $this->featureSet->callMagicCall($method, $arguments);
 472         }
 473         throw new Exception\InvalidArgumentException('Invalid method (' . $method . ') called, caught by ' . __CLASS__ . '::__call()');
 474     }
 475
 476     /**
 477      * __clone
 478      */
 479     public function __clone()
 480     {
 481         $this->resultSetPrototype = (isset($this->resultSetPrototype)) ? clone $this->resultSetPrototype : null;
 482         $this->sql = clone $this->sql;
 483         if (is_object($this->table)) {
 484             $this->table = clone $this->table;
 485         }
 486     }
 487
 488 }