├── Composer
    └── ScriptHandler.php
├── Doctrine
    ├── DBAL
    │   ├── Connection.php
    │   └── Driver
    │   │   └── PDODblib
    │   │       ├── Connection.php
    │   │       └── Driver.php
    ├── ORM
    │   └── Persisters
    │   │   └── Entity
    │   │       ├── BasicEntityPersister.php
    │   │       └── JoinedSubclassPersister.php
    └── Types
    │   └── NTextType.php
├── Helper
    ├── ConnectionHelper.php
    └── PlatformHelper.php
├── LICENSE
├── MediaMonksMssqlBundle.php
├── PDO
    └── PDO.php
├── Platforms
    └── DblibPlatform.php
├── README.md
├── Resources
    └── doc
    │   ├── 0-requirements-nix.rst
    │   ├── 0-requirements-windows.rst
    │   └── 1-setting_up_the_bundle.rst
├── Schema
    └── DblibSchemaManager.php
├── Session
    └── Storage
    │   └── Handler
    │       └── PdoSessionHandler.php
└── composer.json


/Composer/ScriptHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MediaMonks\MssqlBundle\Composer;
 4 | 
 5 | use Composer\Script\Event;
 6 | use Symfony\Component\Finder\Finder;
 7 | 
 8 | /**
 9 |  * @author Robert Slootjes <robert@mediamonks.com>
10 |  */
11 | class ScriptHandler
12 | {
13 |     const DOCTRINE_ORM_PACKAGE_PATH = '/doctrine/orm/lib/';
14 | 
15 |     /**
16 |      * @param Event $event
17 |      */
18 |     public static function ensureDoctrineORMOverrides(Event $event)
19 |     {
20 |         $doctrineOrmPath = self::getDoctrineOrmPath($event);
21 |         if (!file_exists($doctrineOrmPath)) {
22 |             return; // Doctrine ORM does not seem be installed
23 |         }
24 | 
25 |         $finder = new Finder();
26 |         $finder->files()->in($doctrineOrmPath)
27 |             ->exclude([
28 |                 'Decorator',
29 |                 'Event',
30 |                 'Id',
31 |                 'Internal',
32 |                 'Proxy',
33 |                 'Query',
34 |                 'Tools',
35 |                 'Repository',
36 |                 'Tools',
37 |                 'Utility'
38 |             ]);
39 | 
40 |         $baseFind    = 'use Doctrine\ORM\Persisters\Entity\\';
41 |         $baseReplace = 'use MediaMonks\MssqlBundle\Doctrine\ORM\Persisters\Entity\\';
42 |         $replaces    = ['BasicEntityPersister'];
43 | 
44 |         foreach ($finder as $file) {
45 |             $data = file_get_contents($file->getRealpath());
46 |             if (strpos($data, $baseFind) === false) {
47 |                 continue;
48 |             }
49 |             foreach ($replaces as $replace) {
50 |                 $data = str_replace($baseFind . $replace, $baseReplace . $replace, $data);
51 |             }
52 |             file_put_contents($file->getRealpath(), $data);
53 |         }
54 |     }
55 | 
56 |     /**
57 |      * @param Event $event
58 |      * @return string
59 |      */
60 |     public static function getDoctrineOrmPath(Event $event)
61 |     {
62 |         return $event->getComposer()->getConfig()->get('vendor-dir') . self::DOCTRINE_ORM_PACKAGE_PATH;
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------
/Doctrine/DBAL/Connection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MediaMonks\MssqlBundle\Doctrine\DBAL;
 4 | 
 5 | use Doctrine\DBAL\Cache\QueryCacheProfile;
 6 | use Doctrine\DBAL\Connection as BaseConnection;
 7 | use MediaMonks\MssqlBundle\Helper\ConnectionHelper;
 8 | 
 9 | class Connection extends BaseConnection
10 | {
11 |     /**
12 |      * @inheritdoc
13 |      */
14 |     public function executeQuery($query, array $params = [], $types = [], QueryCacheProfile $qcp = null)
15 |     {
16 |         $query = ConnectionHelper::updateQuery($query, $params);
17 |         return parent::executeQuery($query, $params, $types, $qcp);
18 |     }
19 | 
20 |     /**
21 |      * @inheritdoc
22 |      */
23 |     public function executeUpdate($query, array $params = [], array $types = [])
24 |     {
25 |         $query = ConnectionHelper::updateQuery($query, $params);
26 |         return parent::executeUpdate($query, $params, $types);
27 |     }
28 | 
29 | }
30 | 


--------------------------------------------------------------------------------
/Doctrine/DBAL/Driver/PDODblib/Connection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MediaMonks\MssqlBundle\Doctrine\DBAL\Driver\PDODblib;
 4 | 
 5 | use Doctrine\DBAL\Driver\Connection as BaseConnection;
 6 | use Doctrine\DBAL\Driver\PDOConnection;
 7 | 
 8 | class Connection extends PDOConnection implements BaseConnection
 9 | {
10 |     /**
11 |      * {@inheritdoc}
12 |      */
13 |     public function rollback()
14 |     {
15 |         $this->exec('ROLLBACK TRANSACTION');
16 |     }
17 | 
18 |     /**
19 |      * {@inheritdoc}
20 |      */
21 |     public function commit()
22 |     {
23 |         $this->exec('COMMIT TRANSACTION');
24 |     }
25 | 
26 |     /**
27 |      * {@inheritdoc}
28 |      */
29 |     public function beginTransaction()
30 |     {
31 |         $this->exec('BEGIN TRANSACTION');
32 |     }
33 | 
34 |     /**
35 |      * {@inheritdoc}
36 |      */
37 |     public function lastInsertId($name = null)
38 |     {
39 |         $stmt = $this->query('SELECT SCOPE_IDENTITY()');
40 |         $id   = $stmt->fetchColumn();
41 |         $stmt->closeCursor();
42 |         return $id;
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/Doctrine/DBAL/Driver/PDODblib/Driver.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace MediaMonks\MssqlBundle\Doctrine\DBAL\Driver\PDODblib;
  4 | 
  5 | use Doctrine\DBAL\Driver\PDOConnection;
  6 | use Doctrine\DBAL\Connection as DoctrineConnection;
  7 | use MediaMonks\MssqlBundle\Helper\ConnectionHelper;
  8 | use MediaMonks\MssqlBundle\Helper\PlatformHelper;
  9 | use MediaMonks\MssqlBundle\Platforms\DblibPlatform;
 10 | use MediaMonks\MssqlBundle\Schema\DblibSchemaManager;
 11 | 
 12 | /**
 13 |  * @author Scott Morken <scott.morken@pcmail.maricopa.edu>
 14 |  * @author Robert Slootjes <robert@mediamonks.com>
 15 |  */
 16 | class Driver implements \Doctrine\DBAL\Driver
 17 | {
 18 |     const NAME = 'pdo_dblib';
 19 | 
 20 |     /**
 21 |      * Attempts to establish a connection with the underlying driver.
 22 |      *
 23 |      * @param array $params
 24 |      * @param string $username
 25 |      * @param string $password
 26 |      * @param array $driverOptions
 27 |      * @return \Doctrine\DBAL\Driver\Connection
 28 |      */
 29 |     public function connect(array $params, $username = null, $password = null, array $driverOptions = [])
 30 |     {
 31 |         if (PlatformHelper::isWindows()) {
 32 |             return $this->connectWindows($params, $username, $password, $driverOptions);
 33 |         }
 34 |         return $this->connectUnix($params, $username, $password, $driverOptions);
 35 |     }
 36 | 
 37 |     /**
 38 |      * @param array $params
 39 |      * @param null $username
 40 |      * @param null $password
 41 |      * @param array $driverOptions
 42 |      * @return PDOConnection
 43 |      */
 44 |     protected function connectWindows(array $params, $username = null, $password = null, array $driverOptions = [])
 45 |     {
 46 |         return new PDOConnection(
 47 |             $this->constructPdoDsnWindows($params),
 48 |             $username,
 49 |             $password,
 50 |             $driverOptions
 51 |         );
 52 |     }
 53 | 
 54 |     /**
 55 |      * @param array $params
 56 |      * @param null $username
 57 |      * @param null $password
 58 |      * @param array $driverOptions
 59 |      * @return Connection
 60 |      */
 61 |     protected function connectUnix(array $params, $username = null, $password = null, array $driverOptions = [])
 62 |     {
 63 |         $connection = new Connection(
 64 |             $this->constructPdoDsnUnix($params),
 65 |             $username,
 66 |             $password,
 67 |             $driverOptions
 68 |         );
 69 | 
 70 |         ConnectionHelper::setConnectionOptions($connection);
 71 | 
 72 |         return $connection;
 73 |     }
 74 | 
 75 |     /**
 76 |      * Constructs the Dblib PDO DSN.
 77 |      *
 78 |      * @return string  The DSN.
 79 |      */
 80 |     public function constructPdoDsn(array $params)
 81 |     {
 82 |         if (PlatformHelper::isWindows()) {
 83 |             return $this->constructPdoDsnWindows($params);
 84 |         }
 85 |         return $this->constructPdoDsnUnix($params);
 86 |     }
 87 | 
 88 |     /**
 89 |      * @param array $params
 90 |      * @return string
 91 |      */
 92 |     protected function constructPdoDsnWindows(array $params)
 93 |     {
 94 |         $dsn = 'sqlsrv:server=';
 95 | 
 96 |         if (isset($params['host'])) {
 97 |             $dsn .= $params['host'];
 98 |         }
 99 | 
100 |         if (isset($params['port']) && !empty($params['port'])) {
101 |             $dsn .= ',' . $params['port'];
102 |         }
103 | 
104 |         if (isset($params['dbname'])) {
105 |             $dsn .= ';Database=' . $params['dbname'];
106 |         }
107 |         return $dsn;
108 |     }
109 | 
110 |     /**
111 |      * @param array $params
112 |      * @return string
113 |      */
114 |     public function constructPdoDsnUnix(array $params)
115 |     {
116 |         $dsn = 'dblib:';
117 |         if (isset($params['host'])) {
118 |             $dsn .= 'host=' . $params['host'] . ';';
119 |         }
120 |         if (isset($params['port'])) {
121 |             $dsn .= 'port=' . $params['port'] . ';';
122 |         }
123 |         if (isset($params['dbname'])) {
124 |             $dsn .= 'dbname=' . $params['dbname'] . ';';
125 |         }
126 |         if (isset($params['charset'])) {
127 |             $dsn .= 'charset=' . $params['charset'] . ';';
128 |         }
129 | 
130 |         return $dsn;
131 |     }
132 | 
133 |     /**
134 |      * @return DblibPlatform
135 |      */
136 |     public function getDatabasePlatform()
137 |     {
138 |         return new DblibPlatform();
139 |     }
140 | 
141 |     /**
142 |      * @param DoctrineConnection $connection
143 |      * @return DblibSchemaManager
144 |      */
145 |     public function getSchemaManager(DoctrineConnection $connection)
146 |     {
147 |         return new DblibSchemaManager($connection);
148 |     }
149 | 
150 |     /**
151 |      * @return string
152 |      */
153 |     public function getName()
154 |     {
155 |         return self::NAME;
156 |     }
157 | 
158 |     /**
159 |      * @param DoctrineConnection $connection
160 |      * @return mixed
161 |      */
162 |     public function getDatabase(DoctrineConnection $connection)
163 |     {
164 |         $params = $connection->getParams();
165 |         return $params['dbname'];
166 |     }
167 | }
168 | 


--------------------------------------------------------------------------------
/Doctrine/ORM/Persisters/Entity/BasicEntityPersister.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MediaMonks\MssqlBundle\Doctrine\ORM\Persisters\Entity;
 4 | 
 5 | use Doctrine\ORM\Persisters\Entity\BasicEntityPersister as BaseBasicEntityPersister;
 6 | 
 7 | class BasicEntityPersister extends BaseBasicEntityPersister
 8 | {
 9 |     /**
10 |      * {@inheritdoc}
11 |      */
12 |     public function executeInserts()
13 |     {
14 |         if (!$this->queuedInserts) {
15 |             return [];
16 |         }
17 | 
18 |         $postInsertIds  = [];
19 |         $idGenerator    = $this->class->idGenerator;
20 |         $isPostInsertId = $idGenerator->isPostInsertGenerator();
21 |         $tableName      = $this->class->getTableName();
22 | 
23 |         foreach ($this->queuedInserts as $entity) {
24 |             $insertData = $this->prepareInsertData($entity);
25 | 
26 |             $types  = [];
27 |             $params = [];
28 | 
29 |             if (isset($insertData[$tableName])) {
30 |                 foreach ($insertData[$tableName] as $column => $value) {
31 |                     $types[]  = $this->columnTypes[$column];
32 |                     $params[] = $value;
33 |                 }
34 |             }
35 | 
36 |             $this->conn->executeUpdate($this->getInsertSQL(), $params, $types);
37 | 
38 |             if ($isPostInsertId) {
39 |                 $generatedId     = $idGenerator->generate($this->em, $entity);
40 |                 $id              = [
41 |                     $this->class->identifier[0] => $generatedId
42 |                 ];
43 |                 $postInsertIds[] = [
44 |                     'generatedId' => $generatedId,
45 |                     'entity'      => $entity,
46 |                 ];
47 |             } else {
48 |                 $id = $this->class->getIdentifierValues($entity);
49 |             }
50 | 
51 |             if ($this->class->isVersioned) {
52 |                 $this->assignDefaultVersionValue($entity, $id);
53 |             }
54 |         }
55 | 
56 |         $this->queuedInserts = [];
57 | 
58 |         return $postInsertIds;
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/Doctrine/ORM/Persisters/Entity/JoinedSubclassPersister.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MediaMonks\MssqlBundle\Doctrine\ORM\Persisters\Entity;
 4 | 
 5 | use Doctrine\ORM\Persisters\Entity\JoinedSubclassPersister as BaseJoinedSubclassPersister;
 6 | 
 7 | class JoinedSubclassPersister extends BaseJoinedSubclassPersister
 8 | {
 9 |     /**
10 |      * {@inheritdoc}
11 |      */
12 |     public function executeInserts()
13 |     {
14 |         throw new \Exception('Not implemented with UTF8 support yet, implement it or avoid joined subclasses');
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/Doctrine/Types/NTextType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace MediaMonks\MssqlBundle\Doctrine\Types;
 5 | 
 6 | use Doctrine\DBAL\Types\Type;
 7 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 8 | 
 9 | class NTextType extends Type
10 | {
11 |     const NTEXT = 'ntext';
12 | 
13 |     /**
14 |      * {@inheritdoc}
15 |      */
16 |     public function getName()
17 |     {
18 |         return self::NTEXT;
19 |     }
20 | 
21 |     /**
22 |      * {@inheritdoc}
23 |      */
24 |     public function getSQLDeclaration(array $fieldDeclaration, AbstractPlatform $platform)
25 |     {
26 |         return 'NTEXT';
27 |     }
28 | 
29 |     /**
30 |      * {@inheritdoc}
31 |      */
32 |     public function requiresSQLCommentHint(AbstractPlatform $platform)
33 |     {
34 |         return true;
35 |     }
36 | }


--------------------------------------------------------------------------------
/Helper/ConnectionHelper.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MediaMonks\MssqlBundle\Helper;
 4 | 
 5 | class ConnectionHelper
 6 | {
 7 |     /**
 8 |      * @param $connection
 9 |      */
10 |     public static function setConnectionOptions(\PDO $connection)
11 |     {
12 |         if (PlatformHelper::isWindows()) {
13 |             return;
14 |         }
15 | 
16 |         $connection->exec('SET ANSI_WARNINGS ON');
17 |         $connection->exec('SET ANSI_PADDING ON');
18 |         $connection->exec('SET ANSI_NULLS ON');
19 |         $connection->exec('SET QUOTED_IDENTIFIER ON');
20 |         $connection->exec('SET CONCAT_NULL_YIELDS_NULL ON');
21 |     }
22 | 
23 |     /**
24 |      * @param $query
25 |      * @param array $values
26 |      * @return void|mixed
27 |      */
28 |     public static function updateQuery($query, array $values = [])
29 |     {
30 |         if (PlatformHelper::isWindows()) {
31 |             return $query;
32 |         }
33 | 
34 |         for ($i = 0, $offset = 0; $pos = strpos($query, '?', $offset); $i++) {
35 |             $offset = $pos + 1;
36 |             if (isset($values[$i]) && is_string($values[$i])) {
37 |                 $query = substr_replace($query, 'N?', $pos, 1);
38 |                 $offset++;
39 |             }
40 |         }
41 |         return $query;
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/Helper/PlatformHelper.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MediaMonks\MssqlBundle\Helper;
 4 | 
 5 | class PlatformHelper
 6 | {
 7 |     /**
 8 |      * @return bool
 9 |      */
10 |     public static function isWindows()
11 |     {
12 |         return stristr(PHP_OS, 'WIN') && strtolower(PHP_OS) !== 'darwin';
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2016 MediaMonks
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/MediaMonksMssqlBundle.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MediaMonks\MssqlBundle;
 4 | 
 5 | use Symfony\Component\HttpKernel\Bundle\Bundle;
 6 | 
 7 | class MediaMonksMssqlBundle extends Bundle
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/PDO/PDO.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MediaMonks\MssqlBundle\PDO;
 4 | 
 5 | use MediaMonks\MssqlBundle\Helper\ConnectionHelper;
 6 | use MediaMonks\MssqlBundle\Doctrine\DBAL\Driver\PDODblib\Driver;
 7 | 
 8 | class PDO extends \PDO
 9 | {
10 |     /**
11 |      * PDO constructor.
12 |      * @param $host
13 |      * @param $port
14 |      * @param $dbname
15 |      * @param $username
16 |      * @param $passwd
17 |      * @param $options
18 |      */
19 |     public function __construct($host, $port, $dbname, $username, $passwd, $options)
20 |     {
21 |         $driver = new Driver();
22 |         $dsn = $driver->constructPdoDsn([
23 |             'host'   => $host,
24 |             'port'   => $port,
25 |             'dbname' => $dbname
26 |         ]);
27 | 
28 |         parent::__construct($dsn, $username, $passwd, $options);
29 | 
30 |         ConnectionHelper::setConnectionOptions($this);
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/Platforms/DblibPlatform.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MediaMonks\MssqlBundle\Platforms;
 4 | 
 5 | use Doctrine\DBAL\Platforms\SQLServer2008Platform;
 6 | 
 7 | /**
 8 |  * The DblibPlatform provides the behavior, features and SQL dialect of the MsSQL database platform.
 9 |  */
10 | class DblibPlatform extends SQLServer2008Platform
11 | {
12 |     /**
13 |      * {@inheritDoc}
14 |      */
15 |     public function getClobTypeDeclarationSQL(array $field)
16 |     {
17 |         return 'NVARCHAR(MAX)';
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | [![Total Downloads](https://poser.pugx.org/mediamonks/mssql-bundle/downloads)](https://packagist.org/packages/mediamonks/mssql-bundle)
 2 | [![Latest Stable Version](https://poser.pugx.org/mediamonks/mssql-bundle/v/stable)](https://packagist.org/packages/mediamonks/mssql-bundle)
 3 | [![Latest Unstable Version](https://poser.pugx.org/mediamonks/mssql-bundle/v/unstable)](https://packagist.org/packages/mediamonks/mssql-bundle)
 4 | [![SensioLabs Insight](https://img.shields.io/sensiolabs/i/dae91dea-607a-4b55-9c10-593f5908fc5f.svg)](https://insight.sensiolabs.com/projects/dae91dea-607a-4b55-9c10-593f5908fc5f)
 5 | [![License](https://poser.pugx.org/mediamonks/mssql-bundle/license)](https://packagist.org/packages/mediamonks/mssql)
 6 | 
 7 | # MediaMonksMssqlBundle
 8 | 
 9 | This bundle provides a driver which makes Symfony and Doctrine (DBAL and ORM) support dblib driver on *nix systems while also being compatible with sqlsrv on Windows.
10 | 
11 | - Uses pdo_sqlsrv on Windows and pdo_dblib on unix
12 | - Supports UTF-8
13 | - Supports transactions
14 | - Supports Doctrine ORM
15 | - Supports Sonata Admin
16 | - Supports Symfony Sessions
17 | 
18 | There are a few bundles and packages out there which can handle dblib but unfortunately we could not make it work with UTF-8 so we spent a while on cracking this issue. Since others had already done a lot of work on this we felt we had to return the favour to the community and release this bundle.
19 | 
20 | # A Big Thanks
21 | 
22 | - [Realestate.co.nz](http://www.realestate.co.nz/) for their awesome [MssqlBundle](https://github.com/realestateconz/MssqlBundle/) which was the base for this bundle
23 | - [Leaseweb](https://www.leaseweb.com/) for their [PdoDblib package](https://github.com/LeaseWeb/LswDoctrinePdoDblib) which was very useful too
24 | - Michal for his hard work in the past on projects where dblib had to be used, your input for this bundle was very valuable
25 | - Arjen for his dedicated work on the function that prepares the query for supporting UTF-8 ♥
26 | - Tonny & Elmar from the .NET team for their help on working with Microsoft SQL Server
27 | 
28 | # Notes
29 | 
30 | - Do not use pdo_dblib unless you have very good reasons, use a different driver if you get the chance
31 | - You probably need to be change the FreeTDS conf, make sure you can
32 | - Support for ORM requires modifications to some Doctrine files in the vendor folder, a script for Composer which does this automatically is provided in this bundle
33 | - When doing manual queries you should always use executeQuery() and executeUpdate() on Doctrine DBAL
34 | - Named parameters are not supported, UTF-8 characters will be saved as ?
35 | - This bundle was only tested on SQL Server 2008 R2 SP2 and nvarchar fields
36 | - Joined inheritance mapping in ORM is not supported yet since we did not need it, this might be supported in the future
37 | - Symfony session handler does not use locking now, this might be supported in the future
38 | - There are no tests since original tests on Doctrine are also likely to fail, take this bundle as-is but please create a PR if you have found an issue and fixed it
39 | - MediaMonks is not responsible for any data loss, use dblib and this driver at your own risk
40 | 
41 | # Documentation
42 | 
43 | Please refer to the files in the [/Resources/doc](/Resources/doc) folder.
44 | 


--------------------------------------------------------------------------------
/Resources/doc/0-requirements-nix.rst:
--------------------------------------------------------------------------------
 1 | Step 0: Requirements *nix
 2 | =========================
 3 | 
 4 | FreeTDS & PHP Driver
 5 | --------------------
 6 | 
 7 | FreeTDS is a set of libraries for Unix and Linux that allows your programs to
 8 | natively talk to Microsoft SQL Server and Sybase databases.
 9 | 
10 | This bundle needs the ``FreeTDS`` and ``pdo_dblib`` driver to be installed on your system.
11 | 
12 | Installation
13 | ````````````
14 | 
15 | Ubuntu/Debian Linux
16 | '''''''''''''''''''
17 | 
18 | Simply install the correct packages:
19 | 
20 | 1. ``sudo apt-get -y install php56-sybase php56-odbc tdsodbc``
21 | 
22 | OS X
23 | ''''
24 | 
25 | The simplest way to install dblib on OS X is by using `Homebrew`_. This guide will therefore assume that you
26 | have `Homebrew`_ installed, are using `PHP installed with Homebrew`_ and using the native Apache server in OS X.
27 | 
28 | 1. ``brew update``
29 | 2. ``brew install php56-pdo-dblib`` The installation can take some time, be patient!
30 | 
31 | .. note::
32 | 
33 |     Any version of PHP installed should work. Just change ``php56`` in the command to match your version og PHP.
34 | 
35 | Restart your webserver and verify with ``phpinfo();`` if ``pdo_dblib`` is properly installed.
36 | 
37 | FreeTDS Configuration
38 | `````````````````````
39 | 
40 | To finish up we also need to do some modifications to the FreeTDS configuration.
41 | 
42 | You can probably find the config file in `/usr/freetds/freetds.conf` or `/usr/local/etc/freetds.conf`.
43 | pen it with your favorite text editor.
44 | 
45 | In the ``[global]`` section, find a line that looks like
46 | 
47 | .. code-block:: yaml
48 | 
49 |     ; tds version = x
50 | 
51 | Uncomment the line and change the version number to **8.0**, you should have
52 | 
53 | .. code-block:: yaml
54 | 
55 |     tds version = 8.0
56 | 
57 | Then also add the following line below the version
58 | 
59 | .. code-block:: yaml
60 | 
61 |     client charset = UTF-8
62 | 
63 | Save the changes and you are good to go.
64 | 
65 | .. note::
66 |     Although you would expect this to be enough for UTF-8 to be supported it isn't,
67 |     that's why you still need this bundle to make it work.
68 | 
69 | Alternate Configuration
70 | '''''''''''''''''''''''
71 | 
72 | When your FreeTDS config is used by multiple apps and you can not change the
73 | global settings you can create a separate group instead
74 | 
75 | .. code-block:: yaml
76 | 
77 |     [example]
78 |     host = <host_or_ip_of_db_server>
79 |     tds version = 8.0
80 |     client charset = UTF-8
81 | 
82 | Then when you specifiy the host in your Symfony parameters.yml you will use "example"
83 | instead of the host/ip and this block with it's configuration will be used instead
84 | 
85 | .. _Homebrew: http://brew.sh/
86 | .. _PHP installed with Homebrew: https://github.com/Homebrew/homebrew-php#installation


--------------------------------------------------------------------------------
/Resources/doc/0-requirements-windows.rst:
--------------------------------------------------------------------------------
 1 | Step 0: Requirements Windows
 2 | ============================
 3 | 
 4 | PHP Driver
 5 | ----------
 6 | 
 7 | 1. Download the latest version of `Drivers for PHP for SQL Server`_ from the Microsoft website.
 8 | 2. Extract the drivers to a folder where you can find them again
 9 | 3. Copy both dlls (``php_pdo_sqlsrv_*_*.dll`` & and ``php_sqlsrv_*_*.dll``) for your php version and thread safety setting to the extension dir of your php installation
10 | 4. Enable the drivers in your php.ini:
11 |     - extension=php_pdo_sqlsrv_*_*.dll
12 |     - extension=php_pdo_sqlsrv_*_*.dll
13 | 5. Restart your webserver
14 | 
15 | .. _Drivers for PHP for SQL Server: https://www.microsoft.com/en-us/download/details.aspx?id=20098
16 | 


--------------------------------------------------------------------------------
/Resources/doc/1-setting_up_the_bundle.rst:
--------------------------------------------------------------------------------
  1 | Step 1: Setting up the bundle
  2 | =============================
  3 | 
  4 | A) Download the Bundle
  5 | ----------------------
  6 | 
  7 | Open a command console, enter your project directory and execute the
  8 | following command to download the latest stable version of this bundle:
  9 | 
 10 | .. code-block:: bash
 11 | 
 12 |     $ composer require mediamonks/mssql-bundle ~1.0
 13 | 
 14 | This command requires you to have Composer installed globally, as explained
 15 | in the `installation chapter`_ of the Composer documentation.
 16 | 
 17 | B) Enable the Bundle
 18 | --------------------
 19 | 
 20 | Then, enable the bundle by adding it to the list of registered bundles
 21 | in the ``app/AppKernel.php`` file of your project:
 22 | 
 23 | .. code-block:: php
 24 | 
 25 |     <?php
 26 |     // app/AppKernel.php
 27 | 
 28 |     // ...
 29 |     class AppKernel extends Kernel
 30 |     {
 31 |         public function registerBundles()
 32 |         {
 33 |             $bundles = [
 34 |                 // ...
 35 | 
 36 |                 new MediaMonks\MssqlBundle\MediaMonksMssqlBundle(),
 37 |             ];
 38 | 
 39 |             // ...
 40 |         }
 41 | 
 42 |         // ...
 43 |     }
 44 | 
 45 | 
 46 | C) Enable the driver
 47 | --------------------
 48 | 
 49 | Now you should be able to enable the driver by updating your
 50 | Doctrine DBAL config in the ``app/config/config.yml`` so it looks like this:
 51 | 
 52 | .. code-block:: yaml
 53 | 
 54 |     doctrine:
 55 |         dbal:
 56 |             driver_class: MediaMonks\MssqlBundle\Doctrine\DBAL\Driver\PDODblib\Driver
 57 |             wrapper_class: MediaMonks\MssqlBundle\Doctrine\DBAL\Connection
 58 |             host:     "%database_host%"
 59 |             port:     "%database_port%"
 60 |             dbname:   "%database_name%"
 61 |             user:     "%database_user%"
 62 |             password: "%database_password%"
 63 |             charset:  UTF-8
 64 | 
 65 | .. caution::
 66 | 
 67 |     Make sure the ``driver`` parameter is no longer present in your configuration
 68 |     otherwise this bundle will probably not work due to conflicts.
 69 | 
 70 | .. _`installation chapter`: https://getcomposer.org/doc/00-intro.md
 71 | 
 72 | D) Enable the Composer script
 73 | -----------------------------
 74 | 
 75 | For persisting entities with Doctrine ORM it is needed to override some classes within the Doctrine
 76 | ORM namespace. Unfortunately Doctrine uses a lot of private methods which keeps us from using OOP
 77 | to solve this issue. To work around this the namespaces in a few files are modified so Doctrine loads
 78 | our classes instead of theirs to make it work again.
 79 | 
 80 | Open your ``composer.json`` file and make sure the script is added to ``post-install-cmd`` and
 81 | ``post-update-cmd``
 82 | 
 83 | .. code-block:: json
 84 |     "scripts": {
 85 |         "post-install-cmd": [
 86 |             "MediaMonks\\MssqlBundle\\Composer\\ScriptHandler::ensureDoctrineORMOverrides"
 87 |         ],
 88 |         "post-update-cmd": [
 89 |             "Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::buildBootstrap"
 90 |         ]
 91 |     }
 92 | 
 93 | .. note::
 94 |     Probably other scripts are already present, make sure this script is added first.
 95 | 
 96 | .. caution::
 97 |     This will modify files in your ``vendor`` folder, make sure this script is ran when doing automated deploys.
 98 | 
 99 | 
100 | E) Enable database sessions (optional)
101 | ======================================
102 | 
103 | Since the default PDO Session Handler provided by Symfony does not support ``pdo_dblib``
104 | a custom handler is needed. Luckily the configuring it is very similar as configuring the default one.
105 | 
106 | Open up ``app/services.yml`` and add these services:
107 | 
108 | .. code-block:: yaml
109 | 
110 |     services:
111 |         pdo:
112 |             class: MediaMonks\MssqlBundle\PDO\PDO
113 |             arguments:
114 |                 host: "%database_host%"
115 |                 port: "%database_port%"
116 |                 dbname: "%database_name%"
117 |                 user: "%database_user%"
118 |                 password: "%database_password%"
119 |                 options:
120 |             calls:
121 |                 - [setAttribute, [3, 2]] # \PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION
122 | 
123 |         session.handler.pdo:
124 |             class:     MediaMonks\MssqlBundle\Session\Storage\Handler\PdoSessionHandler
125 |             public:    false
126 |             arguments: ["@pdo"]
127 | 
128 | Then open up ``app/config.yml`` and change the session handler id to the one we just created:
129 | 
130 | .. code-block:: yaml
131 | 
132 |     framework:
133 |         session:
134 |             handler_id: session.handler.pdo
135 | 


--------------------------------------------------------------------------------
/Schema/DblibSchemaManager.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MediaMonks\MssqlBundle\Schema;
 4 | 
 5 | use Doctrine\DBAL\Schema\SQLServerSchemaManager;
 6 | 
 7 | class DblibSchemaManager extends SQLServerSchemaManager
 8 | {
 9 |     protected function _getPortableSequenceDefinition($sequence)
10 |     {
11 |         return end($sequence);
12 |     }
13 | 
14 |     public function createDatabase($name)
15 |     {
16 |         $query = "CREATE DATABASE $name";
17 |         if ($this->_conn->options['database_device']) {
18 |             $query .= ' ON ' . $this->_conn->options['database_device'];
19 |             $query .= $this->_conn->options['database_size'] ? '=' .
20 |                 $this->_conn->options['database_size'] : '';
21 |         }
22 |         return $this->_conn->standaloneQuery($query, null, true);
23 |     }
24 | 
25 |     /**
26 |      * lists all database sequences
27 |      *
28 |      * @param string|null $database
29 |      * @return array
30 |      */
31 |     public function listSequences($database = null)
32 |     {
33 |         $query      = "SELECT name FROM sysobjects WHERE xtype = 'U'";
34 |         $tableNames = $this->_conn->fetchAll($query);
35 | 
36 |         return array_map([$this->_conn->formatter, 'fixSequenceName'], $tableNames);
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/Session/Storage/Handler/PdoSessionHandler.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace MediaMonks\MssqlBundle\Session\Storage\Handler;
  4 | 
  5 | use MediaMonks\MssqlBundle\Helper\PlatformHelper;
  6 | 
  7 | /**
  8 |  * This is a copy of the original PdoSessionHandler found in Symfony but due to a limitation in sqlsrv we
  9 |  * need to copy this entire class because Symfony uses a lot of private properties which prevents
 10 |  * us from making only the changes we need, changes we had to do:
 11 |  *
 12 |  * - base64 encode/decode data being saved
 13 |  * - update write() so sqlsrv does not break (https://github.com/symfony/symfony/pull/18501/files)
 14 |  *
 15 |  *
 16 |  * Session handler using a PDO connection to read and write data.
 17 |  *
 18 |  * It works with MySQL, PostgreSQL, Oracle, SQL Server and SQLite and implements
 19 |  * different locking strategies to handle concurrent access to the same session.
 20 |  * Locking is necessary to prevent loss of data due to race conditions and to keep
 21 |  * the session data consistent between read() and write(). With locking, requests
 22 |  * for the same session will wait until the other one finished writing. For this
 23 |  * reason it's best practice to close a session as early as possible to improve
 24 |  * concurrency. PHPs internal files session handler also implements locking.
 25 |  *
 26 |  * Attention: Since SQLite does not support row level locks but locks the whole database,
 27 |  * it means only one session can be accessed at a time. Even different sessions would wait
 28 |  * for another to finish. So saving session in SQLite should only be considered for
 29 |  * development or prototypes.
 30 |  *
 31 |  * Session data is a binary string that can contain non-printable characters like the null byte.
 32 |  * For this reason it must be saved in a binary column in the database like BLOB in MySQL.
 33 |  * Saving it in a character column could corrupt the data. You can use createTable()
 34 |  * to initialize a correctly defined table.
 35 |  *
 36 |  * @see http://php.net/sessionhandlerinterface
 37 |  *
 38 |  * @author Fabien Potencier <fabien@symfony.com>
 39 |  * @author Michael Williams <michael.williams@funsational.com>
 40 |  * @author Tobias Schultze <http://tobion.de>
 41 |  */
 42 | class PdoSessionHandler implements \SessionHandlerInterface
 43 | {
 44 |     /**
 45 |      * No locking is done. This means sessions are prone to loss of data due to
 46 |      * race conditions of concurrent requests to the same session. The last session
 47 |      * write will win in this case. It might be useful when you implement your own
 48 |      * logic to deal with this like an optimistic approach.
 49 |      */
 50 |     const LOCK_NONE = 0;
 51 | 
 52 |     /**
 53 |      * Creates an application-level lock on a session. The disadvantage is that the
 54 |      * lock is not enforced by the database and thus other, unaware parts of the
 55 |      * application could still concurrently modify the session. The advantage is it
 56 |      * does not require a transaction.
 57 |      * This mode is not available for SQLite and not yet implemented for oci and sqlsrv.
 58 |      */
 59 |     const LOCK_ADVISORY = 1;
 60 | 
 61 |     /**
 62 |      * Issues a real row lock. Since it uses a transaction between opening and
 63 |      * closing a session, you have to be careful when you use same database connection
 64 |      * that you also use for your application logic. This mode is the default because
 65 |      * it's the only reliable solution across DBMSs.
 66 |      */
 67 |     const LOCK_TRANSACTIONAL = 2;
 68 | 
 69 |     /**
 70 |      * @var \PDO|null PDO instance or null when not connected yet
 71 |      */
 72 |     private $pdo;
 73 | 
 74 |     /**
 75 |      * @var string|null|false DSN string or null for session.save_path or false when lazy connection disabled
 76 |      */
 77 |     private $dsn = false;
 78 | 
 79 |     /**
 80 |      * @var string Database driver
 81 |      */
 82 |     private $driver;
 83 | 
 84 |     /**
 85 |      * @var string Table name
 86 |      */
 87 |     private $table = 'sessions';
 88 | 
 89 |     /**
 90 |      * @var string Column for session id
 91 |      */
 92 |     private $idCol = 'sess_id';
 93 | 
 94 |     /**
 95 |      * @var string Column for session data
 96 |      */
 97 |     private $dataCol = 'sess_data';
 98 | 
 99 |     /**
100 |      * @var string Column for lifetime
101 |      */
102 |     private $lifetimeCol = 'sess_lifetime';
103 | 
104 |     /**
105 |      * @var string Column for timestamp
106 |      */
107 |     private $timeCol = 'sess_time';
108 | 
109 |     /**
110 |      * @var string Username when lazy-connect
111 |      */
112 |     private $username = '';
113 | 
114 |     /**
115 |      * @var string Password when lazy-connect
116 |      */
117 |     private $password = '';
118 | 
119 |     /**
120 |      * @var array Connection options when lazy-connect
121 |      */
122 |     private $connectionOptions = array();
123 | 
124 |     /**
125 |      * @var int The strategy for locking, see constants
126 |      */
127 |     private $lockMode = self::LOCK_TRANSACTIONAL;
128 | 
129 |     /**
130 |      * It's an array to support multiple reads before closing which is manual, non-standard usage.
131 |      *
132 |      * @var \PDOStatement[] An array of statements to release advisory locks
133 |      */
134 |     private $unlockStatements = array();
135 | 
136 |     /**
137 |      * @var bool True when the current session exists but expired according to session.gc_maxlifetime
138 |      */
139 |     private $sessionExpired = false;
140 | 
141 |     /**
142 |      * @var bool Whether a transaction is active
143 |      */
144 |     private $inTransaction = false;
145 | 
146 |     /**
147 |      * @var bool Whether gc() has been called
148 |      */
149 |     private $gcCalled = false;
150 | 
151 |     /**
152 |      * Constructor.
153 |      *
154 |      * You can either pass an existing database connection as PDO instance or
155 |      * pass a DSN string that will be used to lazy-connect to the database
156 |      * when the session is actually used. Furthermore it's possible to pass null
157 |      * which will then use the session.save_path ini setting as PDO DSN parameter.
158 |      *
159 |      * List of available options:
160 |      *  * db_table: The name of the table [default: sessions]
161 |      *  * db_id_col: The column where to store the session id [default: sess_id]
162 |      *  * db_data_col: The column where to store the session data [default: sess_data]
163 |      *  * db_lifetime_col: The column where to store the lifetime [default: sess_lifetime]
164 |      *  * db_time_col: The column where to store the timestamp [default: sess_time]
165 |      *  * db_username: The username when lazy-connect [default: '']
166 |      *  * db_password: The password when lazy-connect [default: '']
167 |      *  * db_connection_options: An array of driver-specific connection options [default: array()]
168 |      *  * lock_mode: The strategy for locking, see constants [default: LOCK_TRANSACTIONAL]
169 |      *
170 |      * @param \PDO|string|null $pdoOrDsn A \PDO instance or DSN string or null
171 |      * @param array            $options  An associative array of options
172 |      *
173 |      * @throws \InvalidArgumentException When PDO error mode is not PDO::ERRMODE_EXCEPTION
174 |      */
175 |     public function __construct($pdoOrDsn = null, array $options = array())
176 |     {
177 |         if ($pdoOrDsn instanceof \PDO) {
178 |             if (\PDO::ERRMODE_EXCEPTION !== $pdoOrDsn->getAttribute(\PDO::ATTR_ERRMODE)) {
179 |                 throw new \InvalidArgumentException(sprintf('"%s" requires PDO error mode attribute be set to throw Exceptions (i.e. $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION))', __CLASS__));
180 |             }
181 | 
182 |             $this->pdo = $pdoOrDsn;
183 |             $this->driver = $this->pdo->getAttribute(\PDO::ATTR_DRIVER_NAME);
184 |         } else {
185 |             $this->dsn = $pdoOrDsn;
186 |         }
187 | 
188 |         $this->table = isset($options['db_table']) ? $options['db_table'] : $this->table;
189 |         $this->idCol = isset($options['db_id_col']) ? $options['db_id_col'] : $this->idCol;
190 |         $this->dataCol = isset($options['db_data_col']) ? $options['db_data_col'] : $this->dataCol;
191 |         $this->lifetimeCol = isset($options['db_lifetime_col']) ? $options['db_lifetime_col'] : $this->lifetimeCol;
192 |         $this->timeCol = isset($options['db_time_col']) ? $options['db_time_col'] : $this->timeCol;
193 |         $this->username = isset($options['db_username']) ? $options['db_username'] : $this->username;
194 |         $this->password = isset($options['db_password']) ? $options['db_password'] : $this->password;
195 |         $this->connectionOptions = isset($options['db_connection_options']) ? $options['db_connection_options'] : $this->connectionOptions;
196 |         $this->lockMode = isset($options['lock_mode']) ? $options['lock_mode'] : $this->lockMode;
197 | 
198 |         if(!PlatformHelper::isWindows()) {
199 |             $this->lockMode = self::LOCK_NONE;
200 |         }
201 |     }
202 | 
203 |     /**
204 |      * Creates the table to store sessions which can be called once for setup.
205 |      *
206 |      * Session ID is saved in a column of maximum length 128 because that is enough even
207 |      * for a 512 bit configured session.hash_function like Whirlpool. Session data is
208 |      * saved in a BLOB. One could also use a shorter inlined varbinary column
209 |      * if one was sure the data fits into it.
210 |      *
211 |      * @throws \PDOException    When the table already exists
212 |      * @throws \DomainException When an unsupported PDO driver is used
213 |      */
214 |     public function createTable()
215 |     {
216 |         // connect if we are not yet
217 |         $this->getConnection();
218 | 
219 |         switch ($this->driver) {
220 |             case 'mysql':
221 |                 // We use varbinary for the ID column because it prevents unwanted conversions:
222 |                 // - character set conversions between server and client
223 |                 // - trailing space removal
224 |                 // - case-insensitivity
225 |                 // - language processing like é == e
226 |                 $sql = "CREATE TABLE $this->table ($this->idCol VARBINARY(128) NOT NULL PRIMARY KEY, $this->dataCol BLOB NOT NULL, $this->lifetimeCol MEDIUMINT NOT NULL, $this->timeCol INTEGER UNSIGNED NOT NULL) COLLATE utf8_bin, ENGINE = InnoDB";
227 |                 break;
228 |             case 'sqlite':
229 |                 $sql = "CREATE TABLE $this->table ($this->idCol TEXT NOT NULL PRIMARY KEY, $this->dataCol BLOB NOT NULL, $this->lifetimeCol INTEGER NOT NULL, $this->timeCol INTEGER NOT NULL)";
230 |                 break;
231 |             case 'pgsql':
232 |                 $sql = "CREATE TABLE $this->table ($this->idCol VARCHAR(128) NOT NULL PRIMARY KEY, $this->dataCol BYTEA NOT NULL, $this->lifetimeCol INTEGER NOT NULL, $this->timeCol INTEGER NOT NULL)";
233 |                 break;
234 |             case 'oci':
235 |                 $sql = "CREATE TABLE $this->table ($this->idCol VARCHAR2(128) NOT NULL PRIMARY KEY, $this->dataCol BLOB NOT NULL, $this->lifetimeCol INTEGER NOT NULL, $this->timeCol INTEGER NOT NULL)";
236 |                 break;
237 |             case 'sqlsrv':
238 |                 $sql = "CREATE TABLE $this->table ($this->idCol VARCHAR(128) NOT NULL PRIMARY KEY, $this->dataCol VARBINARY(MAX) NOT NULL, $this->lifetimeCol INTEGER NOT NULL, $this->timeCol INTEGER NOT NULL)";
239 |                 break;
240 |             default:
241 |                 throw new \DomainException(sprintf('Creating the session table is currently not implemented for PDO driver "%s".', $this->driver));
242 |         }
243 | 
244 |         try {
245 |             $this->pdo->exec($sql);
246 |         } catch (\PDOException $e) {
247 |             $this->rollback();
248 | 
249 |             throw $e;
250 |         }
251 |     }
252 | 
253 |     /**
254 |      * Returns true when the current session exists but expired according to session.gc_maxlifetime.
255 |      *
256 |      * Can be used to distinguish between a new session and one that expired due to inactivity.
257 |      *
258 |      * @return bool Whether current session expired
259 |      */
260 |     public function isSessionExpired()
261 |     {
262 |         return $this->sessionExpired;
263 |     }
264 | 
265 |     /**
266 |      * {@inheritdoc}
267 |      */
268 |     public function open($savePath, $sessionName)
269 |     {
270 |         if (null === $this->pdo) {
271 |             $this->connect($this->dsn ?: $savePath);
272 |         }
273 | 
274 |         return true;
275 |     }
276 | 
277 |     /**
278 |      * {@inheritdoc}
279 |      */
280 |     public function read($sessionId)
281 |     {
282 |         try {
283 |             return base64_decode($this->doRead($sessionId));
284 |         } catch (\PDOException $e) {
285 |             $this->rollback();
286 | 
287 |             throw $e;
288 |         }
289 |     }
290 | 
291 |     /**
292 |      * {@inheritdoc}
293 |      */
294 |     public function gc($maxlifetime)
295 |     {
296 |         // We delay gc() to close() so that it is executed outside the transactional and blocking read-write process.
297 |         // This way, pruning expired sessions does not block them from being started while the current session is used.
298 |         $this->gcCalled = true;
299 | 
300 |         return true;
301 |     }
302 | 
303 |     /**
304 |      * {@inheritdoc}
305 |      */
306 |     public function destroy($sessionId)
307 |     {
308 |         // delete the record associated with this id
309 |         $sql = "DELETE FROM $this->table WHERE $this->idCol = :id";
310 | 
311 |         try {
312 |             $stmt = $this->pdo->prepare($sql);
313 |             $stmt->bindParam(':id', $sessionId, \PDO::PARAM_STR);
314 |             $stmt->execute();
315 |         } catch (\PDOException $e) {
316 |             $this->rollback();
317 | 
318 |             throw $e;
319 |         }
320 | 
321 |         return true;
322 |     }
323 | 
324 |     /**
325 |      * {@inheritdoc}
326 |      */
327 |     public function write($sessionId, $data)
328 |     {
329 |         $data = base64_encode($data);
330 | 
331 |         $maxlifetime = (int) ini_get('session.gc_maxlifetime');
332 | 
333 |         try {
334 |             // We use a single MERGE SQL query when supported by the database.
335 |             $mergeSql = $this->getMergeSql();
336 | 
337 |             if (null !== $mergeSql) {
338 |                 $mergeStmt = $this->pdo->prepare($mergeSql);
339 |                 if ('sqlsrv' === $this->driver || 'oci' === $this->driver) {
340 |                     $mergeStmt->bindParam(1, $sessionId, \PDO::PARAM_STR);
341 |                     $mergeStmt->bindParam(2, $sessionId, \PDO::PARAM_STR);
342 |                     $mergeStmt->bindParam(3, $data, \PDO::PARAM_LOB);
343 |                     $mergeStmt->bindParam(4, $maxlifetime, \PDO::PARAM_INT);
344 |                     $mergeStmt->bindValue(5, time(), \PDO::PARAM_INT);
345 |                     $mergeStmt->bindParam(6, $data, \PDO::PARAM_LOB);
346 |                     $mergeStmt->bindParam(7, $maxlifetime, \PDO::PARAM_INT);
347 |                     $mergeStmt->bindValue(8, time(), \PDO::PARAM_INT);
348 |                 }
349 |                 else {
350 |                     $mergeStmt->bindParam(':id', $sessionId, \PDO::PARAM_STR);
351 |                     $mergeStmt->bindParam(':data', $data, \PDO::PARAM_LOB);
352 |                     $mergeStmt->bindParam(':lifetime', $maxlifetime, \PDO::PARAM_INT);
353 |                     $mergeStmt->bindValue(':time', time(), \PDO::PARAM_INT);
354 |                 }
355 |                 $mergeStmt->execute();
356 |                 return true;
357 |             }
358 | 
359 |             $updateStmt = $this->pdo->prepare(
360 |                 "UPDATE $this->table SET $this->dataCol = :data, $this->lifetimeCol = :lifetime, $this->timeCol = :time WHERE $this->idCol = :id"
361 |             );
362 |             $updateStmt->bindParam(':id', $sessionId, \PDO::PARAM_STR);
363 |             $updateStmt->bindParam(':data', $data, \PDO::PARAM_LOB);
364 |             $updateStmt->bindParam(':lifetime', $maxlifetime, \PDO::PARAM_INT);
365 |             $updateStmt->bindValue(':time', time(), \PDO::PARAM_INT);
366 |             $updateStmt->execute();
367 | 
368 |             // When MERGE is not supported, like in Postgres, we have to use this approach that can result in
369 |             // duplicate key errors when the same session is written simultaneously (given the LOCK_NONE behavior).
370 |             // We can just catch such an error and re-execute the update. This is similar to a serializable
371 |             // transaction with retry logic on serialization failures but without the overhead and without possible
372 |             // false positives due to longer gap locking.
373 |             if (!$updateStmt->rowCount()) {
374 |                 try {
375 |                     $insertStmt = $this->pdo->prepare(
376 |                         "INSERT INTO $this->table ($this->idCol, $this->dataCol, $this->lifetimeCol, $this->timeCol) VALUES (:id, :data, :lifetime, :time)"
377 |                     );
378 |                     $insertStmt->bindParam(':id', $sessionId, \PDO::PARAM_STR);
379 |                     $insertStmt->bindParam(':data', $data, \PDO::PARAM_LOB);
380 |                     $insertStmt->bindParam(':lifetime', $maxlifetime, \PDO::PARAM_INT);
381 |                     $insertStmt->bindValue(':time', time(), \PDO::PARAM_INT);
382 |                     $insertStmt->execute();
383 |                 } catch (\PDOException $e) {
384 |                     // Handle integrity violation SQLSTATE 23000 (or a subclass like 23505 in Postgres) for duplicate keys
385 |                     if (0 === strpos($e->getCode(), '23')) {
386 |                         $updateStmt->execute();
387 |                     } else {
388 |                         throw $e;
389 |                     }
390 |                 }
391 |             }
392 |         } catch (\PDOException $e) {
393 |             $this->rollback();
394 | 
395 |             throw $e;
396 |         }
397 | 
398 |         return true;
399 |     }
400 | 
401 |     /**
402 |      * {@inheritdoc}
403 |      */
404 |     public function close()
405 |     {
406 |         $this->commit();
407 | 
408 |         while ($unlockStmt = array_shift($this->unlockStatements)) {
409 |             $unlockStmt->execute();
410 |         }
411 | 
412 |         if ($this->gcCalled) {
413 |             $this->gcCalled = false;
414 | 
415 |             // delete the session records that have expired
416 |             $sql = "DELETE FROM $this->table WHERE $this->lifetimeCol + $this->timeCol < :time";
417 | 
418 |             $stmt = $this->pdo->prepare($sql);
419 |             $stmt->bindValue(':time', time(), \PDO::PARAM_INT);
420 |             $stmt->execute();
421 |         }
422 | 
423 |         if (false !== $this->dsn) {
424 |             $this->pdo = null; // only close lazy-connection
425 |         }
426 | 
427 |         return true;
428 |     }
429 | 
430 |     /**
431 |      * Lazy-connects to the database.
432 |      *
433 |      * @param string $dsn DSN string
434 |      */
435 |     private function connect($dsn)
436 |     {
437 |         $this->pdo = new \PDO($dsn, $this->username, $this->password, $this->connectionOptions);
438 |         $this->pdo->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
439 |         $this->driver = $this->pdo->getAttribute(\PDO::ATTR_DRIVER_NAME);
440 |     }
441 | 
442 |     /**
443 |      * Helper method to begin a transaction.
444 |      *
445 |      * Since SQLite does not support row level locks, we have to acquire a reserved lock
446 |      * on the database immediately. Because of https://bugs.php.net/42766 we have to create
447 |      * such a transaction manually which also means we cannot use PDO::commit or
448 |      * PDO::rollback or PDO::inTransaction for SQLite.
449 |      *
450 |      * Also MySQLs default isolation, REPEATABLE READ, causes deadlock for different sessions
451 |      * due to http://www.mysqlperformanceblog.com/2013/12/12/one-more-innodb-gap-lock-to-avoid/ .
452 |      * So we change it to READ COMMITTED.
453 |      */
454 |     private function beginTransaction()
455 |     {
456 |         if (!$this->inTransaction) {
457 |             if ('sqlite' === $this->driver) {
458 |                 $this->pdo->exec('BEGIN IMMEDIATE TRANSACTION');
459 |             } else {
460 |                 if ('mysql' === $this->driver) {
461 |                     $this->pdo->exec('SET TRANSACTION ISOLATION LEVEL READ COMMITTED');
462 |                 }
463 |                 $this->pdo->beginTransaction();
464 |             }
465 |             $this->inTransaction = true;
466 |         }
467 |     }
468 | 
469 |     /**
470 |      * Helper method to commit a transaction.
471 |      */
472 |     private function commit()
473 |     {
474 |         if ($this->inTransaction) {
475 |             try {
476 |                 // commit read-write transaction which also releases the lock
477 |                 if ('sqlite' === $this->driver) {
478 |                     $this->pdo->exec('COMMIT');
479 |                 } else {
480 |                     $this->pdo->commit();
481 |                 }
482 |                 $this->inTransaction = false;
483 |             } catch (\PDOException $e) {
484 |                 $this->rollback();
485 | 
486 |                 throw $e;
487 |             }
488 |         }
489 |     }
490 | 
491 |     /**
492 |      * Helper method to rollback a transaction.
493 |      */
494 |     private function rollback()
495 |     {
496 |         // We only need to rollback if we are in a transaction. Otherwise the resulting
497 |         // error would hide the real problem why rollback was called. We might not be
498 |         // in a transaction when not using the transactional locking behavior or when
499 |         // two callbacks (e.g. destroy and write) are invoked that both fail.
500 |         if ($this->inTransaction) {
501 |             if ('sqlite' === $this->driver) {
502 |                 $this->pdo->exec('ROLLBACK');
503 |             } else {
504 |                 $this->pdo->rollBack();
505 |             }
506 |             $this->inTransaction = false;
507 |         }
508 |     }
509 | 
510 |     /**
511 |      * Reads the session data in respect to the different locking strategies.
512 |      *
513 |      * We need to make sure we do not return session data that is already considered garbage according
514 |      * to the session.gc_maxlifetime setting because gc() is called after read() and only sometimes.
515 |      *
516 |      * @param string $sessionId Session ID
517 |      *
518 |      * @return string The session data
519 |      */
520 |     private function doRead($sessionId)
521 |     {
522 |         $this->sessionExpired = false;
523 | 
524 |         if (self::LOCK_ADVISORY === $this->lockMode) {
525 |             $this->unlockStatements[] = $this->doAdvisoryLock($sessionId);
526 |         }
527 | 
528 |         $selectSql = $this->getSelectSql();
529 |         $selectStmt = $this->pdo->prepare($selectSql);
530 |         $selectStmt->bindParam(':id', $sessionId, \PDO::PARAM_STR);
531 |         $selectStmt->execute();
532 | 
533 |         $sessionRows = $selectStmt->fetchAll(\PDO::FETCH_NUM);
534 | 
535 |         if ($sessionRows) {
536 |             if ($sessionRows[0][1] + $sessionRows[0][2] < time()) {
537 |                 $this->sessionExpired = true;
538 | 
539 |                 return '';
540 |             }
541 | 
542 |             return is_resource($sessionRows[0][0]) ? stream_get_contents($sessionRows[0][0]) : $sessionRows[0][0];
543 |         }
544 | 
545 |         if (self::LOCK_TRANSACTIONAL === $this->lockMode && 'sqlite' !== $this->driver) {
546 |             // Exclusive-reading of non-existent rows does not block, so we need to do an insert to block
547 |             // until other connections to the session are committed.
548 |             try {
549 |                 $insertStmt = $this->pdo->prepare(
550 |                     "INSERT INTO $this->table ($this->idCol, $this->dataCol, $this->lifetimeCol, $this->timeCol) VALUES (:id, :data, :lifetime, :time)"
551 |                 );
552 |                 $insertStmt->bindParam(':id', $sessionId, \PDO::PARAM_STR);
553 |                 $insertStmt->bindValue(':data', '', \PDO::PARAM_LOB);
554 |                 $insertStmt->bindValue(':lifetime', 0, \PDO::PARAM_INT);
555 |                 $insertStmt->bindValue(':time', time(), \PDO::PARAM_INT);
556 |                 $insertStmt->execute();
557 |             } catch (\PDOException $e) {
558 |                 // Catch duplicate key error because other connection created the session already.
559 |                 // It would only not be the case when the other connection destroyed the session.
560 |                 if (0 === strpos($e->getCode(), '23')) {
561 |                     // Retrieve finished session data written by concurrent connection. SELECT
562 |                     // FOR UPDATE is necessary to avoid deadlock of connection that starts reading
563 |                     // before we write (transform intention to real lock).
564 |                     $selectStmt->execute();
565 |                     $sessionRows = $selectStmt->fetchAll(\PDO::FETCH_NUM);
566 | 
567 |                     if ($sessionRows) {
568 |                         return is_resource($sessionRows[0][0]) ? stream_get_contents($sessionRows[0][0]) : $sessionRows[0][0];
569 |                     }
570 | 
571 |                     return '';
572 |                 }
573 | 
574 |                 throw $e;
575 |             }
576 |         }
577 | 
578 |         return '';
579 |     }
580 | 
581 |     /**
582 |      * Executes an application-level lock on the database.
583 |      *
584 |      * @param string $sessionId Session ID
585 |      *
586 |      * @return \PDOStatement The statement that needs to be executed later to release the lock
587 |      *
588 |      * @throws \DomainException When an unsupported PDO driver is used
589 |      *
590 |      * @todo implement missing advisory locks
591 |      *       - for oci using DBMS_LOCK.REQUEST
592 |      *       - for sqlsrv using sp_getapplock with LockOwner = Session
593 |      */
594 |     private function doAdvisoryLock($sessionId)
595 |     {
596 |         switch ($this->driver) {
597 |             case 'mysql':
598 |                 // should we handle the return value? 0 on timeout, null on error
599 |                 // we use a timeout of 50 seconds which is also the default for innodb_lock_wait_timeout
600 |                 $stmt = $this->pdo->prepare('SELECT GET_LOCK(:key, 50)');
601 |                 $stmt->bindValue(':key', $sessionId, \PDO::PARAM_STR);
602 |                 $stmt->execute();
603 | 
604 |                 $releaseStmt = $this->pdo->prepare('DO RELEASE_LOCK(:key)');
605 |                 $releaseStmt->bindValue(':key', $sessionId, \PDO::PARAM_STR);
606 | 
607 |                 return $releaseStmt;
608 |             case 'pgsql':
609 |                 // Obtaining an exclusive session level advisory lock requires an integer key.
610 |                 // So we convert the HEX representation of the session id to an integer.
611 |                 // Since integers are signed, we have to skip one hex char to fit in the range.
612 |                 if (4 === PHP_INT_SIZE) {
613 |                     $sessionInt1 = hexdec(substr($sessionId, 0, 7));
614 |                     $sessionInt2 = hexdec(substr($sessionId, 7, 7));
615 | 
616 |                     $stmt = $this->pdo->prepare('SELECT pg_advisory_lock(:key1, :key2)');
617 |                     $stmt->bindValue(':key1', $sessionInt1, \PDO::PARAM_INT);
618 |                     $stmt->bindValue(':key2', $sessionInt2, \PDO::PARAM_INT);
619 |                     $stmt->execute();
620 | 
621 |                     $releaseStmt = $this->pdo->prepare('SELECT pg_advisory_unlock(:key1, :key2)');
622 |                     $releaseStmt->bindValue(':key1', $sessionInt1, \PDO::PARAM_INT);
623 |                     $releaseStmt->bindValue(':key2', $sessionInt2, \PDO::PARAM_INT);
624 |                 } else {
625 |                     $sessionBigInt = hexdec(substr($sessionId, 0, 15));
626 | 
627 |                     $stmt = $this->pdo->prepare('SELECT pg_advisory_lock(:key)');
628 |                     $stmt->bindValue(':key', $sessionBigInt, \PDO::PARAM_INT);
629 |                     $stmt->execute();
630 | 
631 |                     $releaseStmt = $this->pdo->prepare('SELECT pg_advisory_unlock(:key)');
632 |                     $releaseStmt->bindValue(':key', $sessionBigInt, \PDO::PARAM_INT);
633 |                 }
634 | 
635 |                 return $releaseStmt;
636 |             case 'sqlite':
637 |                 throw new \DomainException('SQLite does not support advisory locks.');
638 |             default:
639 |                 throw new \DomainException(sprintf('Advisory locks are currently not implemented for PDO driver "%s".', $this->driver));
640 |         }
641 |     }
642 | 
643 |     /**
644 |      * Return a locking or nonlocking SQL query to read session information.
645 |      *
646 |      * @return string The SQL string
647 |      *
648 |      * @throws \DomainException When an unsupported PDO driver is used
649 |      */
650 |     private function getSelectSql()
651 |     {
652 |         if (self::LOCK_TRANSACTIONAL === $this->lockMode) {
653 |             $this->beginTransaction();
654 | 
655 |             switch ($this->driver) {
656 |                 case 'mysql':
657 |                 case 'oci':
658 |                 case 'pgsql':
659 |                     return "SELECT $this->dataCol, $this->lifetimeCol, $this->timeCol FROM $this->table WHERE $this->idCol = :id FOR UPDATE";
660 |                 case 'sqlsrv':
661 |                     return "SELECT $this->dataCol, $this->lifetimeCol, $this->timeCol FROM $this->table WITH (UPDLOCK, ROWLOCK) WHERE $this->idCol = :id";
662 |                 case 'sqlite':
663 |                     // we already locked when starting transaction
664 |                     break;
665 |                 default:
666 |                     throw new \DomainException(sprintf('Transactional locks are currently not implemented for PDO driver "%s".', $this->driver));
667 |             }
668 |         }
669 | 
670 |         return "SELECT $this->dataCol, $this->lifetimeCol, $this->timeCol FROM $this->table WHERE $this->idCol = :id";
671 |     }
672 | 
673 |     /**
674 |      * Returns a merge/upsert (i.e. insert or update) SQL query when supported by the database for writing session data.
675 |      *
676 |      * @return string|null The SQL string or null when not supported
677 |      */
678 |     private function getMergeSql()
679 |     {
680 |         switch ($this->driver) {
681 |             case 'mysql':
682 |                 return "INSERT INTO $this->table ($this->idCol, $this->dataCol, $this->lifetimeCol, $this->timeCol) VALUES (:id, :data, :lifetime, :time) ".
683 |                 "ON DUPLICATE KEY UPDATE $this->dataCol = VALUES($this->dataCol), $this->lifetimeCol = VALUES($this->lifetimeCol), $this->timeCol = VALUES($this->timeCol)";
684 |             case 'oci':
685 |                 // DUAL is Oracle specific dummy table
686 |                 return "MERGE INTO $this->table USING DUAL ON ($this->idCol = ?) ".
687 |                 "WHEN NOT MATCHED THEN INSERT ($this->idCol, $this->dataCol, $this->lifetimeCol, $this->timeCol) VALUES (?, ?, ?, ?) ".
688 |                 "WHEN MATCHED THEN UPDATE SET $this->dataCol = ?, $this->lifetimeCol = ?, $this->timeCol = ?";
689 |             case 'sqlsrv' === $this->driver && version_compare($this->pdo->getAttribute(\PDO::ATTR_SERVER_VERSION), '10', '>='):
690 |                 // MERGE is only available since SQL Server 2008 and must be terminated by semicolon
691 |                 // It also requires HOLDLOCK according to http://weblogs.sqlteam.com/dang/archive/2009/01/31/UPSERT-Race-Condition-With-MERGE.aspx
692 |                 return "MERGE INTO $this->table WITH (HOLDLOCK) USING (SELECT 1 AS dummy) AS src ON ($this->idCol = ?) ".
693 |                 "WHEN NOT MATCHED THEN INSERT ($this->idCol, $this->dataCol, $this->lifetimeCol, $this->timeCol) VALUES (?, ?, ?, ?) ".
694 |                 "WHEN MATCHED THEN UPDATE SET $this->dataCol = ?, $this->lifetimeCol = ?, $this->timeCol = ?;";
695 |             case 'sqlite':
696 |                 return "INSERT OR REPLACE INTO $this->table ($this->idCol, $this->dataCol, $this->lifetimeCol, $this->timeCol) VALUES (:id, :data, :lifetime, :time)";
697 |         }
698 |     }
699 | 
700 |     /**
701 |      * Return a PDO instance.
702 |      *
703 |      * @return \PDO
704 |      */
705 |     protected function getConnection()
706 |     {
707 |         if (null === $this->pdo) {
708 |             $this->connect($this->dsn ?: ini_get('session.save_path'));
709 |         }
710 | 
711 |         return $this->pdo;
712 |     }
713 | }
714 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "mediamonks/mssql-bundle",
 3 |   "type": "symfony-bundle",
 4 |   "description": "Symfony Bundle for working with Microsoft SQL Server on *nix (dblib) and Windows (sqlsrv) with UTF-8 and transactions support",
 5 |   "keywords": [
 6 |     "mssql",
 7 |     "dblib",
 8 |     "sqlsrv",
 9 |     "symfony",
10 |     "bundle",
11 |     "freetds",
12 |     "pdo_dblib",
13 |     "pdo_sqlsrv",
14 |     "sqlserver",
15 |     "utf8",
16 |     "utf-8",
17 |     "unicode"
18 |   ],
19 |   "homepage": "https://www.mediamonks.com/",
20 |   "license": "MIT",
21 |   "authors": [
22 |     {
23 |       "name": "Robert Slootjes",
24 |       "email": "robert@mediamonks.com",
25 |       "homepage": "https://github.com/slootjes"
26 |     },
27 |     {
28 |       "name": "Arjen Warendorff",
29 |       "email": "arjen@mediamonks.com"
30 |     },
31 |     {
32 |       "name": "Michal Kristin",
33 |       "email": "michal@mediamonks.com"
34 |     },
35 |     {
36 |       "name": "Realestate.co.nz",
37 |       "homepage": "http://www.realestate.co.nz"
38 |     },
39 |     {
40 |       "name": "Ken Golovin",
41 |       "homepage": "https://github.com/pasinter"
42 |     }
43 |   ],
44 |   "require": {
45 |     "php": "^5.4|~7.0"
46 |   },
47 |   "suggest": {
48 |     "symfony/framework-bundle": "For when using this in Symfony"
49 |   },
50 |   "autoload": {
51 |     "psr-4": {
52 |       "MediaMonks\\MssqlBundle\\": ""
53 |     }
54 |   },
55 |   "extra": {
56 |     "branch-alias": {
57 |       "dev-master": "1.0-dev"
58 |     }
59 |   }
60 | }
61 | 


--------------------------------------------------------------------------------