interface/modules/zend_modules/library/Zend/Db/Adapter/Driver/Pdo/Connection.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\Adapter\Driver\Pdo;
  11
  12 use Zend\Db\Adapter\Driver\ConnectionInterface;
  13 use Zend\Db\Adapter\Exception;
  14 use Zend\Db\Adapter\Profiler;
  15
  16 class Connection implements ConnectionInterface, Profiler\ProfilerAwareInterface
  17 {
  18     /**
  19      * @var Pdo
  20      */
  21     protected $driver = null;
  22
  23     /**
  24      * @var Profiler\ProfilerInterface
  25      */
  26     protected $profiler = null;
  27
  28     /**
  29      * @var string
  30      */
  31     protected $driverName = null;
  32
  33     /**
  34      * @var array
  35      */
  36     protected $connectionParameters = array();
  37
  38     /**
  39      * @var \PDO
  40      */
  41     protected $resource = null;
  42
  43     /**
  44      * @var bool
  45      */
  46     protected $inTransaction = false;
  47
  48     /**
  49      * Constructor
  50      *
  51      * @param array|\PDO|null $connectionParameters
  52      * @throws Exception\InvalidArgumentException
  53      */
  54     public function __construct($connectionParameters = null)
  55     {
  56         if (is_array($connectionParameters)) {
  57             $this->setConnectionParameters($connectionParameters);
  58         } elseif ($connectionParameters instanceof \PDO) {
  59             $this->setResource($connectionParameters);
  60         } elseif (null !== $connectionParameters) {
  61             throw new Exception\InvalidArgumentException('$connection must be an array of parameters, a PDO object or null');
  62         }
  63     }
  64
  65     /**
  66      * Set driver
  67      *
  68      * @param Pdo $driver
  69      * @return Connection
  70      */
  71     public function setDriver(Pdo $driver)
  72     {
  73         $this->driver = $driver;
  74         return $this;
  75     }
  76
  77     /**
  78      * @param Profiler\ProfilerInterface $profiler
  79      * @return Connection
  80      */
  81     public function setProfiler(Profiler\ProfilerInterface $profiler)
  82     {
  83         $this->profiler = $profiler;
  84         return $this;
  85     }
  86
  87     /**
  88      * @return null|Profiler\ProfilerInterface
  89      */
  90     public function getProfiler()
  91     {
  92         return $this->profiler;
  93     }
  94
  95     /**
  96      * Get driver name
  97      *
  98      * @return null|string
  99      */
 100     public function getDriverName()
 101     {
 102         return $this->driverName;
 103     }
 104
 105     /**
 106      * Set connection parameters
 107      *
 108      * @param array $connectionParameters
 109      * @return void
 110      */
 111     public function setConnectionParameters(array $connectionParameters)
 112     {
 113         $this->connectionParameters = $connectionParameters;
 114         if (isset($connectionParameters['dsn'])) {
 115             $this->driverName = substr($connectionParameters['dsn'], 0,
 116                 strpos($connectionParameters['dsn'], ':')
 117             );
 118         } elseif (isset($connectionParameters['pdodriver'])) {
 119             $this->driverName = strtolower($connectionParameters['pdodriver']);
 120         } elseif (isset($connectionParameters['driver'])) {
 121             $this->driverName = strtolower(substr(
 122                 str_replace(array('-', '_', ' '), '', $connectionParameters['driver']),
 123                 3
 124             ));
 125         }
 126     }
 127
 128     /**
 129      * Get connection parameters
 130      *
 131      * @return array
 132      */
 133     public function getConnectionParameters()
 134     {
 135         return $this->connectionParameters;
 136     }
 137
 138     /**
 139      * Get current schema
 140      *
 141      * @return string
 142      */
 143     public function getCurrentSchema()
 144     {
 145         if (!$this->isConnected()) {
 146             $this->connect();
 147         }
 148
 149         switch ($this->driverName) {
 150             case 'mysql':
 151                 $sql = 'SELECT DATABASE()';
 152                 break;
 153             case 'sqlite':
 154                 return 'main';
 155             case 'pgsql':
 156             default:
 157                 $sql = 'SELECT CURRENT_SCHEMA';
 158                 break;
 159         }
 160
 161         /** @var $result \PDOStatement */
 162         $result = $this->resource->query($sql);
 163         if ($result instanceof \PDOStatement) {
 164             return $result->fetchColumn();
 165         }
 166         return false;
 167     }
 168
 169     /**
 170      * Set resource
 171      *
 172      * @param  \PDO $resource
 173      * @return Connection
 174      */
 175     public function setResource(\PDO $resource)
 176     {
 177         $this->resource = $resource;
 178         $this->driverName = strtolower($this->resource->getAttribute(\PDO::ATTR_DRIVER_NAME));
 179         return $this;
 180     }
 181
 182     /**
 183      * Get resource
 184      *
 185      * @return \PDO
 186      */
 187     public function getResource()
 188     {
 189         if (!$this->isConnected()) {
 190             $this->connect();
 191         }
 192         return $this->resource;
 193     }
 194
 195     /**
 196      * Connect
 197      *
 198      * @return Connection
 199      * @throws Exception\InvalidConnectionParametersException
 200      * @throws Exception\RuntimeException
 201      */
 202     public function connect()
 203     {
 204         if ($this->resource) {
 205             return $this;
 206         }
 207
 208         $dsn = $username = $password = $hostname = $database = null;
 209         $options = array();
 210         foreach ($this->connectionParameters as $key => $value) {
 211             switch (strtolower($key)) {
 212                 case 'dsn':
 213                     $dsn = $value;
 214                     break;
 215                 case 'driver':
 216                     $value = strtolower($value);
 217                     if (strpos($value, 'pdo') === 0) {
 218                         $pdoDriver = strtolower(substr(str_replace(array('-', '_', ' '), '', $value), 3));
 219                     }
 220                     break;
 221                 case 'pdodriver':
 222                     $pdoDriver = (string) $value;
 223                     break;
 224                 case 'user':
 225                 case 'username':
 226                     $username = (string) $value;
 227                     break;
 228                 case 'pass':
 229                 case 'password':
 230                     $password = (string) $value;
 231                     break;
 232                 case 'host':
 233                 case 'hostname':
 234                     $hostname = (string) $value;
 235                     break;
 236                 case 'port':
 237                     $port = (int) $value;
 238                     break;
 239                 case 'database':
 240                 case 'dbname':
 241                     $database = (string) $value;
 242                     break;
 243                 case 'driver_options':
 244                 case 'options':
 245                     $value = (array) $value;
 246                     $options = array_diff_key($options, $value) + $value;
 247                     break;
 248                 default:
 249                     $options[$key] = $value;
 250                     break;
 251             }
 252         }
 253
 254         if (!isset($dsn) && isset($pdoDriver)) {
 255             $dsn = array();
 256             switch ($pdoDriver) {
 257                 case 'sqlite':
 258                     $dsn[] = $database;
 259                     break;
 260                 default:
 261                     if (isset($database)) {
 262                         $dsn[] = "dbname={$database}";
 263                     }
 264                     if (isset($hostname)) {
 265                         $dsn[] = "host={$hostname}";
 266                     }
 267                     if (isset($port)) {
 268                         $dsn[] = "port={$port}";
 269                     }
 270                     break;
 271             }
 272             $dsn = $pdoDriver . ':' . implode(';', $dsn);
 273         } elseif (!isset($dsn)) {
 274             throw new Exception\InvalidConnectionParametersException(
 275                 'A dsn was not provided or could not be constructed from your parameters',
 276                 $this->connectionParameters
 277             );
 278         }
 279
 280         try {
 281             $this->resource = new \PDO($dsn, $username, $password, $options);
 282             $this->resource->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
 283             $this->driverName = strtolower($this->resource->getAttribute(\PDO::ATTR_DRIVER_NAME));
 284         } catch (\PDOException $e) {
 285             $code = $e->getCode();
 286             if (!is_long($code)) {
 287                 $code = null;
 288             }
 289             throw new Exception\RuntimeException('Connect Error: ' . $e->getMessage(), $code, $e);
 290         }
 291
 292         return $this;
 293     }
 294
 295     /**
 296      * Is connected
 297      *
 298      * @return bool
 299      */
 300     public function isConnected()
 301     {
 302         return ($this->resource instanceof \PDO);
 303     }
 304
 305     /**
 306      * Disconnect
 307      *
 308      * @return Connection
 309      */
 310     public function disconnect()
 311     {
 312         if ($this->isConnected()) {
 313             $this->resource = null;
 314         }
 315         return $this;
 316     }
 317
 318     /**
 319      * Begin transaction
 320      *
 321      * @return Connection
 322      */
 323     public function beginTransaction()
 324     {
 325         if (!$this->isConnected()) {
 326             $this->connect();
 327         }
 328         $this->resource->beginTransaction();
 329         $this->inTransaction = true;
 330         return $this;
 331     }
 332
 333     /**
 334      * Commit
 335      *
 336      * @return Connection
 337      */
 338     public function commit()
 339     {
 340         if (!$this->isConnected()) {
 341             $this->connect();
 342         }
 343
 344         $this->resource->commit();
 345         $this->inTransaction = false;
 346         return $this;
 347     }
 348
 349     /**
 350      * Rollback
 351      *
 352      * @return Connection
 353      * @throws Exception\RuntimeException
 354      */
 355     public function rollback()
 356     {
 357         if (!$this->isConnected()) {
 358             throw new Exception\RuntimeException('Must be connected before you can rollback');
 359         }
 360
 361         if (!$this->inTransaction) {
 362             throw new Exception\RuntimeException('Must call beginTransaction() before you can rollback');
 363         }
 364
 365         $this->resource->rollBack();
 366         return $this;
 367     }
 368
 369     /**
 370      * Execute
 371      *
 372      * @param $sql
 373      * @return Result
 374      * @throws Exception\InvalidQueryException
 375      */
 376     public function execute($sql)
 377     {
 378         if (!$this->isConnected()) {
 379             $this->connect();
 380         }
 381
 382         if ($this->profiler) {
 383             $this->profiler->profilerStart($sql);
 384         }
 385
 386         $resultResource = $this->resource->query($sql);
 387
 388         if ($this->profiler) {
 389             $this->profiler->profilerFinish($sql);
 390         }
 391
 392         if ($resultResource === false) {
 393             $errorInfo = $this->resource->errorInfo();
 394             throw new Exception\InvalidQueryException($errorInfo[2]);
 395         }
 396
 397         $result = $this->driver->createResult($resultResource, $sql);
 398         return $result;
 399
 400     }
 401
 402     /**
 403      * Prepare
 404      *
 405      * @param string $sql
 406      * @return Statement
 407      */
 408     public function prepare($sql)
 409     {
 410         if (!$this->isConnected()) {
 411             $this->connect();
 412         }
 413
 414         $statement = $this->driver->createStatement($sql);
 415         return $statement;
 416     }
 417
 418     /**
 419      * Get last generated id
 420      *
 421      * @param string $name
 422      * @return int|null|false
 423      */
 424     public function getLastGeneratedValue($name = null)
 425     {
 426         if ($name === null && $this->driverName == 'pgsql') {
 427             return null;
 428         }
 429
 430         try {
 431             return $this->resource->lastInsertId($name);
 432         } catch (\Exception $e) {
 433             // do nothing
 434         }
 435         return false;
 436     }
 437 }