vendor\kafoso\doctrine-firebird-driver\src\Driver\FirebirdInterbase\Connection.php line 103

Open in your IDE?
  1. <?php
  2. namespace IST\DoctrineFirebirdDriver\Driver\FirebirdInterbase;
  4. use Doctrine\DBAL\Driver\Connection as ConnectionInterface;
  5. use Doctrine\DBAL\Driver\ServerInfoAwareConnection;
  6. use IST\DoctrineFirebirdDriver\Driver\ConfigurationInterface;
  8. /**
  9.  * Based on https://github.com/helicon-os/doctrine-dbal
  10.  */
  11. class Connection implements ConnectionInterface, ServerInfoAwareConnection
  12. {
  13.     const TRANSACTIONS_MAXIMUM_LEVEL = 20;
  15.     /**
  16.      * @var Configuration
  17.      */
  18.     private $_configuration;
  20.     /**
  21.      * @var resource (ibase_pconnect or ibase_connect)
  22.      */
  23.     private $_ibaseConnectionRc;
  25.     /**
  26.      * @var int
  27.      */
  28.     private $_ibaseTransactionLevel = 0;
  30.     /**
  31.      * @var resource
  32.      */
  33.     private $_ibaseActiveTransaction = null;
  35.     /**
  36.      * Isolation level used when a transaction is started.
  37.      * @var int
  38.      */
  39.     protected $attrDcTransIsolationLevel = \Doctrine\DBAL\Connection::TRANSACTION_READ_COMMITTED;
  41.     /**
  42.      * Wait timeout used in transactions
  43.      *
  44.      * @var integer  Number of seconds to wait.
  45.      */
  46.     protected $attrDcTransWait = 5;
  48.     /**
  49.      * True if auto-commit is enabled
  50.      * @var boolean
  51.      */
  52.     protected $attrAutoCommit = true;
  54.     /**
  55.      * @throws Exception
  56.      */
  57.     public function __construct(Configuration $configuration)
  58.     {
  59.         $this->_configuration = $configuration;
  60.         foreach ($this->_configuration->getDriverOptions() as $k => $v) {
  61.             $this->setAttribute($k, $v);
  62.         }
  63.         $this->connect();
  64.     }
  66.     public function __destruct()
  67.     {
  68.         $this->autoCommit();
  69.         $success = @ibase_close($this->_ibaseConnectionRc);
  70.         if (false == $success) {
  71.             $this->checkLastApiCall();
  72.         }
  73.     }
  75.     public function connect()
  76.     {
  77.         if (!$this->_ibaseConnectionRc || !is_resource($this->_ibaseConnectionRc)) {
  78.             if ($this->_configuration->isPersistent()) {
  79.                 $this->_ibaseConnectionRc = @ibase_pconnect(
  80.                     $this->_configuration->getFullHostString(),
  81.                     $this->_configuration->getUsername(),
  82.                     $this->_configuration->getPassword(),
  83.                     $this->_configuration->getCharset(),
  84.                     $this->_configuration->getBuffers(),
  85.                     $this->_configuration->getDialect()
  86.                 );
  87.             } else {
  88.                 $this->_ibaseConnectionRc = @ibase_connect(
  89.                     $this->_configuration->getFullHostString(),
  90.                     $this->_configuration->getUsername(),
  91.                     $this->_configuration->getPassword(),
  92.                     $this->_configuration->getCharset(),
  93.                     $this->_configuration->getBuffers(),
  94.                     $this->_configuration->getDialect()
  95.                 );
  96.             }
  97.             if (!is_resource($this->_ibaseConnectionRc)) {
  98.                 $this->checkLastApiCall();
  99.             }
  100.             if (!is_resource($this->_ibaseConnectionRc)) {
  101.                 throw Exception::fromErrorInfo($this->errorInfo());
  102.             }
  103.             $this->_ibaseActiveTransaction = $this->createTransaction(true);
  104.         }
  105.     }
  107.     /**
  108.      * {@inheritDoc}
  109.      *
  110.      * Additionally to the standard driver attributes, the attribute
  111.      * {@link Configuration::ATTR_DOCTRINE_DEFAULT_TRANS_ISOLATION_LEVEL} can be used to control
  112.      * the isolation level used for transactions
  113.      *
  114.      * @param string $attribute
  115.      * @param mixed $value
  116.      */
  117.     public function setAttribute($attribute, $value)
  118.     {
  119.         switch ($attribute) {
  120.             case Configuration::ATTR_DOCTRINE_DEFAULT_TRANS_ISOLATION_LEVEL:
  121.                 $this->attrDcTransIsolationLevel = $value;
  122.                 break;
  123.             case Configuration::ATTR_DOCTRINE_DEFAULT_TRANS_WAIT:
  124.                 $this->attrDcTransWait = $value;
  125.                 break;
  126.             case \PDO::ATTR_AUTOCOMMIT:
  127.                 $this->attrAutoCommit = $value;
  128.                 break;
  129.         }
  130.     }
  131.     /**
  132.      * {@inheritDoc}
  133.      *
  134.      * @param string $attribute
  135.      * @return mixed
  136.      */
  137.     public function getAttribute($attribute)
  138.     {
  139.         switch ($attribute) {
  140.             case Configuration::ATTR_DOCTRINE_DEFAULT_TRANS_ISOLATION_LEVEL:
  141.                 return $this->attrDcTransIsolationLevel;
  142.             case Configuration::ATTR_DOCTRINE_DEFAULT_TRANS_WAIT:
  143.                 return $this->attrDcTransWait;
  144.             case \PDO::ATTR_AUTOCOMMIT:
  145.                 return $this->attrAutoCommit;
  146.         }
  147.     }
  149.     /**
  150.      * @return ConfigurationInterface
  151.      */
  152.     public function getConfiguration()
  153.     {
  154.         return $this->_configuration;
  155.     }
  157.     /**
  158.      * @return resource (ibase_pconnect or ibase_connect)
  159.      */
  160.     public function getInterbaseConnectionResource()
  161.     {
  162.         return $this->_ibaseConnectionRc;
  163.     }
  165.     /**
  166.      * {@inheritdoc}
  167.      */
  168.     public function getServerVersion()
  169.     {
  170.         return ibase_server_info($this->_ibaseConnectionRc, IBASE_SVC_SERVER_VERSION);
  171.     }
  173.     /**
  174.      * {@inheritdoc}
  175.      */
  176.     public function requiresQueryForServerVersion()
  177.     {
  178.         return false;
  179.     }
  181.     /**
  182.      * {@inheritdoc}
  183.      */
  184.     public function prepare($prepareString)
  185.     {
  186.         return new Statement($this, $prepareString);
  187.     }
  189.     /**
  190.      * {@inheritdoc}
  191.      */
  192.     public function query()
  193.     {
  194.         $args = func_get_args();
  195.         $sql = $args[0];
  196.         $stmt = $this->prepare($sql);
  197.         $stmt->execute();
  198.         return $stmt;
  199.     }
  201.     /**
  202.      * {@inheritdoc}
  203.      */
  204.     public function quote($input, $type=\PDO::PARAM_STR)
  205.     {
  206.         if (is_int($value) || is_float($value)) {
  207.             return $value;
  208.         }
  209.         $value = str_replace("'", "''", $value);
  210.         return "'" . addcslashes($value, "\000\n\r\\\032") . "'";
  211.     }
  213.     /**
  214.      * {@inheritdoc}
  215.      */
  216.     public function exec($statement)
  217.     {
  218.         $stmt = $this->prepare($statement);
  219.         $stmt->execute();
  220.         return $stmt->rowCount();
  221.     }
  223.     /**
  224.      * {@inheritdoc}
  225.      */
  226.     public function lastInsertId($name = null)
  227.     {
  228.         if ($name === null) {
  229.             return false;
  230.         }
  231.         $sql = "SELECT GEN_ID('{$name}', 0) LAST_VAL FROM RDB\$DATABASE";
  232.         $stmt = $this->query($sql);
  233.         $result = $stmt->fetchColumn(0);
  234.         return $result;
  235.     }
  237.     /**
  238.      * @param int $isolationLevel
  239.      * @param int $timeout
  240.      * @return string
  241.      */
  242.     public function getStartTransactionSql($isolationLevel, $timeout = 5)
  243.     {
  244.         $result = "";
  245.         switch ($isolationLevel) {
  246.             case \Doctrine\DBAL\Connection::TRANSACTION_READ_UNCOMMITTED: {
  247.                     $result .= 'SET TRANSACTION READ WRITE ISOLATION LEVEL READ COMMITTED RECORD_VERSION';
  248.                     break;
  249.                 }
  250.             case \Doctrine\DBAL\Connection::TRANSACTION_READ_COMMITTED: {
  251.                     $result .= 'SET TRANSACTION READ WRITE ISOLATION LEVEL READ COMMITTED RECORD_VERSION';
  252.                     break;
  253.                 }
  254.             case \Doctrine\DBAL\Connection::TRANSACTION_REPEATABLE_READ: {
  255.                     $result .= 'SET TRANSACTION READ WRITE ISOLATION LEVEL SNAPSHOT ';
  256.                     break;
  257.                 }
  258.             case \Doctrine\DBAL\Connection::TRANSACTION_SERIALIZABLE: {
  259.                     $result .= 'SET TRANSACTION READ WRITE ISOLATION LEVEL SNAPSHOT TABLE STABILITY';
  260.                     break;
  261.                 }
  262.         }
  263.         if (($this->attrDcTransWait > 0)) {
  264.             $result .= ' WAIT LOCK TIMEOUT ' . $this->attrDcTransWait;
  265.         } elseif  (($this->attrDcTransWait === -1)) {
  266.             $result .= ' WAIT';
  267.         } else {
  268.             $result .= ' NO WAIT';
  269.         }
  270.         return $result;
  271.     }
  273.     /**
  274.      * {@inheritdoc}
  275.      */
  276.     public function beginTransaction()
  277.     {
  278.         if ($this->_ibaseTransactionLevel < 1) {
  279.             $this->_ibaseActiveTransaction = $this->createTransaction(true);
  280.             $this->_ibaseTransactionLevel++;
  281.         }
  282.         return true;
  283.     }
  285.     /**
  286.      * {@inheritdoc}
  287.      */
  288.     public function commit()
  289.     {
  290.         if ($this->_ibaseTransactionLevel > 0) {
  291.             if (!$this->_ibaseActiveTransaction || false == is_resource($this->_ibaseActiveTransaction)) {
  292.                 throw new \RuntimeException(sprintf(
  293.                     "No active transaction. \$this->_ibaseTransactionLevel = %d",
  294.                     $this->_ibaseTransactionLevel
  295.                 ));
  296.             }
  297.             $success = @ibase_commit($this->_ibaseActiveTransaction);
  298.             if (false == $success) {
  299.                 $this->checkLastApiCall();
  300.             }
  301.             $this->_ibaseTransactionLevel--;
  302.         }
  303.         if (0 == $this->_ibaseTransactionLevel) {
  304.             $this->_ibaseActiveTransaction = $this->createTransaction(true);
  305.         }
  306.         return true;
  307.     }
  309.     /**
  310.      * Commits the transaction if autocommit is enabled no explicte transaction has been started.
  311.      * @throws \RuntimeException
  312.      * @return null|bool
  313.      */
  314.     public function autoCommit()
  315.     {
  316.         if ($this->attrAutoCommit && $this->_ibaseTransactionLevel < 1) {
  317.             if (!$this->_ibaseActiveTransaction || false == is_resource($this->_ibaseActiveTransaction)) {
  318.                 throw new \RuntimeException(sprintf(
  319.                     "No active transaction. \$this->_ibaseTransactionLevel = %d",
  320.                     $this->_ibaseTransactionLevel
  321.                 ));
  322.             }
  323.             $success = @ibase_commit_ret($this->getActiveTransaction());
  324.             if (false == $success) {
  325.                 $this->checkLastApiCall();
  326.             }
  327.             return true;
  328.         }
  329.         return null;
  330.     }
  332.     /**
  333.      * {@inheritdoc)
  334.      * @throws \RuntimeException
  335.      */
  336.     public function rollBack()
  337.     {
  338.         if ($this->_ibaseTransactionLevel > 0) {
  339.             if (!$this->_ibaseActiveTransaction || false == is_resource($this->_ibaseActiveTransaction)) {
  340.                 throw new \RuntimeException(sprintf(
  341.                     "No active transaction. \$this->_ibaseTransactionLevel = %d",
  342.                     $this->_ibaseTransactionLevel
  343.                 ));
  344.             }
  345.             $success = @ibase_rollback($this->_ibaseActiveTransaction);
  346.             if (false == $success) {
  347.                 $this->checkLastApiCall();
  348.             }
  349.             $this->_ibaseTransactionLevel--;
  350.         }
  351.         $this->_ibaseActiveTransaction = $this->createTransaction(true);
  352.         return true;
  353.     }
  355.     /**
  356.      * {@inheritdoc}
  357.      */
  358.     public function errorCode()
  359.     {
  360.         return ibase_errcode();
  361.     }
  363.     /**
  364.      * {@inheritdoc}
  365.      */
  366.     public function errorInfo()
  367.     {
  368.         $errorCode = $this->errorCode();
  369.         if ($errorCode) {
  370.             return [
  371.                 'code' => $errorCode,
  372.                 'message' => ibase_errmsg(),
  373.             ];
  374.         }
  375.         return [
  376.             'code' => 0,
  377.             'message' => null,
  378.         ];
  379.     }
  381.     /**
  382.      * @throws \RuntimeException
  383.      * @return resource
  384.      */
  385.     public function getActiveTransaction()
  386.     {
  387.         $this->connect();
  388.         if (!$this->_ibaseActiveTransaction || false == is_resource($this->_ibaseActiveTransaction)) {
  389.             throw new \RuntimeException(sprintf(
  390.                 "No active transaction. \$this->_ibaseTransactionLevel = %d",
  391.                 $this->_ibaseTransactionLevel
  392.             ));
  393.         }
  394.         return $this->_ibaseActiveTransaction;
  395.     }
  397.     /**
  398.      * Checks ibase_error and raises an exception if an error occured
  399.      *
  400.      * @throws Exception
  401.      */
  402.     protected function checkLastApiCall()
  403.     {
  404.         $lastError = $this->errorInfo();
  405.         if (isset($lastError['code']) && $lastError['code']) {
  406.             throw Exception::fromErrorInfo($lastError);
  407.         }
  408.     }
  410.     /**
  411.      * @param bool $commitDefaultTransaction
  412.      * @return resource The ibase transaction.
  413.      */
  414.     protected function createTransaction($commitDefaultTransaction = true)
  415.     {
  416.         if ($commitDefaultTransaction) {
  417.             @ibase_commit($this->_ibaseConnectionRc);
  418.         }
  419.         $sql = $this->getStartTransactionSql($this->attrDcTransIsolationLevel);
  420.         $result = @ibase_query($this->_ibaseConnectionRc, $sql);
  421.         if (false == is_resource($result)) {
  422.             $this->checkLastApiCall();
  423.         }
  424.         return $result;
  425.     }
  426. }