Add a proper and unflawed JsonType

docs/en/reference/types.rst

@@ -368,6 +368,25 @@ using comma delimited ``explode()`` or ``null`` if no data is present.
     This basically means that every array item other than ``string``
     will loose its type awareness.
 
+json
+^^^^
+
+Maps and converts array data based on PHP's JSON encoding functions.
+If you know that the data to be stored always is in a valid UTF-8
+encoded JSON format string, you should consider using this type.
+Values retrieved from the database are always converted to PHP's ``array`` or 
+``null`` types using PHP's ``json_decode()`` function.
+
+.. note::
+
+    Some vendors have a native JSON type and Doctrine will use it if possible
+    and otherwise silently fall back to the vendor's ``text`` type to ensure
+    the most efficient storage requirements.
+    If the vendor does not have a native JSON type, this type requires a SQL
+    column comment hint so that it can be reverse engineered from the database.
+    Doctrine cannot map back this type properly on vendors not supporting column
+    comments and will fall back to ``text`` type instead.
+
 json_array
 ^^^^^^^^^^
 

lib/Doctrine/DBAL/Types/JsonType.php

+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the MIT license. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\DBAL\Types;
+
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+
+/**
+ * Type generating json objects values
+ *
+ * @since  2.6
+ * @author Baptiste Clavié <clavie.b@gmail.com>
+ */
+class JsonType extends Type
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function getSQLDeclaration(array $fieldDeclaration, AbstractPlatform $platform)
+    {
+        return $platform->getJsonTypeDeclarationSQL($fieldDeclaration);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function convertToDatabaseValue($value, AbstractPlatform $platform)
+    {
+        if (null === $value) {
+            return null;
+        }
+
+        return json_encode($value);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function convertToPHPValue($value, AbstractPlatform $platform)
+    {
+        if ($value === null || $value === '') {
+            return null;
+        }
+
+        if (is_resource($value)) {
+            $value = stream_get_contents($value);
+        }
+
+        $val = json_decode($value, true);
+
+        if (json_last_error() !== JSON_ERROR_NONE) {
+            throw ConversionException::conversionFailed($value, $this->getName());
+        }
+
+        return $val;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getName()
+    {
+        return Type::JSON;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function requiresSQLCommentHint(AbstractPlatform $platform)
+    {
+        /*
+         * should be switched back to the platform detection at 3.0, when
+         * JsonArrayType will be dropped
+         */
+        //return ! $platform->hasNativeJsonType();
+        return true;
+    }
+}

lib/Doctrine/DBAL/Types/Type.php

@@ -36,6 +36,7 @@ abstract class Type
     const TARRAY = 'array';
     const SIMPLE_ARRAY = 'simple_array';
     const JSON_ARRAY = 'json_array';
+    const JSON = 'json';
     const BIGINT = 'bigint';
     const BOOLEAN = 'boolean';
     const DATETIME = 'datetime';
@@ -70,6 +71,7 @@ abstract class Type
         self::TARRAY => 'Doctrine\DBAL\Types\ArrayType',
         self::SIMPLE_ARRAY => 'Doctrine\DBAL\Types\SimpleArrayType',
         self::JSON_ARRAY => 'Doctrine\DBAL\Types\JsonArrayType',
+        self::JSON => 'Doctrine\DBAL\Types\JsonType',
         self::OBJECT => 'Doctrine\DBAL\Types\ObjectType',
         self::BOOLEAN => 'Doctrine\DBAL\Types\BooleanType',
         self::INTEGER => 'Doctrine\DBAL\Types\IntegerType',

tests/Doctrine/Tests/DBAL/Types/JsonTest.php

+<?php
+
+namespace Doctrine\Tests\DBAL\Types;
+
+use Doctrine\DBAL\Types\Type;
+use Doctrine\Tests\DBAL\Mocks\MockPlatform;
+
+class JsonTest extends \Doctrine\Tests\DbalTestCase
+{
+    /**
+     * @var \Doctrine\Tests\DBAL\Mocks\MockPlatform
+     */
+    protected $platform;
+
+    /**
+     * @var \Doctrine\DBAL\Types\JsonType
+     */
+    protected $type;
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function setUp()
+    {
+        $this->platform = new MockPlatform();
+        $this->type     = Type::getType('json');
+    }
+
+    public function testReturnsBindingType()
+    {
+        $this->assertSame(\PDO::PARAM_STR, $this->type->getBindingType());
+    }
+
+    public function testReturnsName()
+    {
+        $this->assertSame(Type::JSON, $this->type->getName());
+    }
+
+    public function testReturnsSQLDeclaration()
+    {
+        $this->assertSame('DUMMYJSON', $this->type->getSQLDeclaration(array(), $this->platform));
+    }
+
+    public function testJsonNullConvertsToPHPValue()
+    {
+        $this->assertNull($this->type->convertToPHPValue(null, $this->platform));
+    }
+
+    public function testJsonEmptyStringConvertsToPHPValue()
+    {
+        $this->assertNull($this->type->convertToPHPValue('', $this->platform));
+    }
+
+    public function testJsonStringConvertsToPHPValue()
+    {
+        $value         = array('foo' => 'bar', 'bar' => 'foo');
+        $databaseValue = json_encode($value);
+        $phpValue      = $this->type->convertToPHPValue($databaseValue, $this->platform);
+
+        $this->assertEquals($value, $phpValue);
+    }
+
+    /** @dataProvider providerFailure */
+    public function testConversionFailure($data)
+    {
+        $this->setExpectedException('Doctrine\DBAL\Types\ConversionException');
+        $this->type->convertToPHPValue($data, $this->platform);
+    }
+
+    public function providerFailure()
+    {
+        return array(array('a'), array('{'));
+    }
+
+    public function testJsonResourceConvertsToPHPValue()
+    {
+        $value         = array('foo' => 'bar', 'bar' => 'foo');
+        $databaseValue = fopen('data://text/plain;base64,' . base64_encode(json_encode($value)), 'r');
+        $phpValue      = $this->type->convertToPHPValue($databaseValue, $this->platform);
+
+        $this->assertSame($value, $phpValue);
+    }
+
+    public function testRequiresSQLCommentHint()
+    {
+        $this->assertTrue($this->type->requiresSQLCommentHint($this->platform));
+    }
+}