MySqlSchemaManagerTest::testColumnDefaultValuesCurrentTimeAndDate() - Code Metrics - Inspection of "MariaDB 10.2 support (also fix maria version detec..." - doctrine/dbal - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions
Pull Request — master (#2825)

by Sébastien
created 2017-10-13 10:06 UTC
testColumnDefaultValuesCurrentTimeAndDate() B

↳ Parent: MySqlSchemaManagerTest
Complexity

Conditions	2
Paths	2
Size

Total Lines	31
Code Lines	19
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
c	1
b	0
f	0
dl	0
loc	31
rs	8.8571
cc	2
eloc	19
nc	2
nop	0
<?php

namespace Doctrine\Tests\DBAL\Functional\Schema;

use Doctrine\DBAL\Platforms\MariaDb1027Platform;
use Doctrine\DBAL\Platforms\MySqlPlatform;
use Doctrine\DBAL\Schema\Comparator;
use Doctrine\DBAL\Schema\Schema;
use Doctrine\DBAL\Schema\Table;
use Doctrine\DBAL\Types\Type;
use Doctrine\Tests\Types\MySqlPointType;

class MySqlSchemaManagerTest extends SchemaManagerFunctionalTestCase
{

    protected function setUp()
    {
        parent::setUp();

        if (!Type::hasType('point')) {
            Type::addType('point', MySqlPointType::class);
        }
    }

    public function testSwitchPrimaryKeyColumns()
    {
        $tableOld = new Table("switch_primary_key_columns");
        $tableOld->addColumn('foo_id', 'integer');
        $tableOld->addColumn('bar_id', 'integer');

        $this->_sm->createTable($tableOld);
        $tableFetched = $this->_sm->listTableDetails("switch_primary_key_columns");
        $tableNew = clone $tableFetched;
        $tableNew->setPrimaryKey(array('bar_id', 'foo_id'));

        $comparator = new Comparator;
        $this->_sm->alterTable($comparator->diffTable($tableFetched, $tableNew));


        $table      = $this->_sm->listTableDetails('switch_primary_key_columns');
        $primaryKey = $table->getPrimaryKeyColumns();

        self::assertCount(2, $primaryKey);
        self::assertContains('bar_id', $primaryKey);
        self::assertContains('foo_id', $primaryKey);
    }

    public function testDiffTableBug()
    {
        $schema = new Schema();
        $table = $schema->createTable('diffbug_routing_translations');
        $table->addColumn('id', 'integer');
        $table->addColumn('route', 'string');
        $table->addColumn('locale', 'string');
        $table->addColumn('attribute', 'string');
        $table->addColumn('localized_value', 'string');
        $table->addColumn('original_value', 'string');
        $table->setPrimaryKey(array('id'));
        $table->addUniqueIndex(array('route', 'locale', 'attribute'));
        $table->addIndex(array('localized_value')); // this is much more selective than the unique index

        $this->_sm->createTable($table);
        $tableFetched = $this->_sm->listTableDetails("diffbug_routing_translations");

        $comparator = new Comparator;
        $diff = $comparator->diffTable($tableFetched, $table);

        self::assertFalse($diff, "no changes expected.");
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }

    public function testFulltextIndex()

    {
        $table = new Table('fulltext_index');
        $table->addColumn('text', 'text');
        $table->addIndex(array('text'), 'f_index');
        $table->addOption('engine', 'MyISAM');

        $index = $table->getIndex('f_index');
        $index->addFlag('fulltext');

        $this->_sm->dropAndCreateTable($table);

        $indexes = $this->_sm->listTableIndexes('fulltext_index');
        self::assertArrayHasKey('f_index', $indexes);
        self::assertTrue($indexes['f_index']->hasFlag('fulltext'));
    }

    public function testSpatialIndex()

    {
        $table = new Table('spatial_index');
        $table->addColumn('point', 'point');
        $table->addIndex(array('point'), 's_index');
        $table->addOption('engine', 'MyISAM');

        $index = $table->getIndex('s_index');
        $index->addFlag('spatial');

        $this->_sm->dropAndCreateTable($table);

        $indexes = $this->_sm->listTableIndexes('spatial_index');
        self::assertArrayHasKey('s_index', $indexes);
        self::assertTrue($indexes['s_index']->hasFlag('spatial'));
    }

    /**
     * @group DBAL-400
     */
    public function testAlterTableAddPrimaryKey()
    {
        $table = new Table('alter_table_add_pk');
        $table->addColumn('id', 'integer');
        $table->addColumn('foo', 'integer');
        $table->addIndex(array('id'), 'idx_id');

        $this->_sm->createTable($table);

        $comparator = new Comparator();
        $diffTable  = clone $table;

        $diffTable->dropIndex('idx_id');
        $diffTable->setPrimaryKey(array('id'));

        $this->_sm->alterTable($comparator->diffTable($table, $diffTable));


        $table = $this->_sm->listTableDetails("alter_table_add_pk");

        self::assertFalse($table->hasIndex('idx_id'));
        self::assertTrue($table->hasPrimaryKey());
    }

    /**
     * @group DBAL-464
     */
    public function testDropPrimaryKeyWithAutoincrementColumn()
    {
        $table = new Table("drop_primary_key");
        $table->addColumn('id', 'integer', array('primary' => true, 'autoincrement' => true));
        $table->addColumn('foo', 'integer', array('primary' => true));
        $table->setPrimaryKey(array('id', 'foo'));

        $this->_sm->dropAndCreateTable($table);

        $diffTable = clone $table;

        $diffTable->dropPrimaryKey();

        $comparator = new Comparator();

        $this->_sm->alterTable($comparator->diffTable($table, $diffTable));


        $table = $this->_sm->listTableDetails("drop_primary_key");

        self::assertFalse($table->hasPrimaryKey());
        self::assertFalse($table->getColumn('id')->getAutoincrement());
    }

    /**
     * @group DBAL-789
     */
    public function testDoesNotPropagateDefaultValuesForUnsupportedColumnTypes()
    {
        if ($this->_sm->getDatabasePlatform() instanceof MariaDb1027Platform) {
            $this->markTestSkipped('MariaDb102Platform supports default values for BLOB and TEXT columns and will propagate values');
        }

        $table = new Table("text_blob_default_value");
        $table->addColumn('def_text', 'text', ['default' => 'def']);
        $table->addColumn('def_text_null', 'text', ['notnull' => false, 'default' => 'def']);
        $table->addColumn('def_blob', 'blob', ['default' => 'def']);
        $table->addColumn('def_blob_null', 'blob', ['notnull' => false, 'default' => 'def']);

        $this->_sm->dropAndCreateTable($table);

        $onlineTable = $this->_sm->listTableDetails("text_blob_default_value");

        self::assertNull($onlineTable->getColumn('def_text')->getDefault());
        self::assertNull($onlineTable->getColumn('def_text_null')->getDefault());
        self::assertFalse($onlineTable->getColumn('def_text_null')->getNotnull());
        self::assertNull($onlineTable->getColumn('def_blob')->getDefault());
        self::assertNull($onlineTable->getColumn('def_blob_null')->getDefault());
        self::assertFalse($onlineTable->getColumn('def_blob_null')->getNotnull());

        $comparator = new Comparator();

        $this->_sm->alterTable($comparator->diffTable($table, $onlineTable));


        $onlineTable = $this->_sm->listTableDetails("text_blob_default_value");

        self::assertNull($onlineTable->getColumn('def_text')->getDefault());
        self::assertNull($onlineTable->getColumn('def_text_null')->getDefault());
        self::assertFalse($onlineTable->getColumn('def_text_null')->getNotnull());
        self::assertNull($onlineTable->getColumn('def_blob')->getDefault());
        self::assertNull($onlineTable->getColumn('def_blob_null')->getDefault());
        self::assertFalse($onlineTable->getColumn('def_blob_null')->getNotnull());
    }

    public function testColumnCollation()

    {
        $table = new Table('test_collation');
        $table->addOption('collate', $collation = 'latin1_swedish_ci');
        $table->addOption('charset', 'latin1');
        $table->addColumn('id', 'integer');
        $table->addColumn('text', 'text');
        $table->addColumn('foo', 'text')->setPlatformOption('collation', 'latin1_swedish_ci');
        $table->addColumn('bar', 'text')->setPlatformOption('collation', 'utf8_general_ci');
        $this->_sm->dropAndCreateTable($table);

        $columns = $this->_sm->listTableColumns('test_collation');

        self::assertArrayNotHasKey('collation', $columns['id']->getPlatformOptions());
        self::assertEquals('latin1_swedish_ci', $columns['text']->getPlatformOption('collation'));
        self::assertEquals('latin1_swedish_ci', $columns['foo']->getPlatformOption('collation'));
        self::assertEquals('utf8_general_ci', $columns['bar']->getPlatformOption('collation'));
    }

    /**
     * @group DBAL-843
     */
    public function testListLobTypeColumns()
    {
        $tableName = 'lob_type_columns';
        $table = new Table($tableName);

        $table->addColumn('col_tinytext', 'text', array('length' => MySqlPlatform::LENGTH_LIMIT_TINYTEXT));
        $table->addColumn('col_text', 'text', array('length' => MySqlPlatform::LENGTH_LIMIT_TEXT));
        $table->addColumn('col_mediumtext', 'text', array('length' => MySqlPlatform::LENGTH_LIMIT_MEDIUMTEXT));
        $table->addColumn('col_longtext', 'text');

        $table->addColumn('col_tinyblob', 'text', array('length' => MySqlPlatform::LENGTH_LIMIT_TINYBLOB));
        $table->addColumn('col_blob', 'blob', array('length' => MySqlPlatform::LENGTH_LIMIT_BLOB));
        $table->addColumn('col_mediumblob', 'blob', array('length' => MySqlPlatform::LENGTH_LIMIT_MEDIUMBLOB));
        $table->addColumn('col_longblob', 'blob');

        $this->_sm->dropAndCreateTable($table);

        $platform = $this->_sm->getDatabasePlatform();
        $offlineColumns = $table->getColumns();
        $onlineColumns = $this->_sm->listTableColumns($tableName);

        self::assertSame(
            $platform->getClobTypeDeclarationSQL($offlineColumns['col_tinytext']->toArray()),
            $platform->getClobTypeDeclarationSQL($onlineColumns['col_tinytext']->toArray())
        );
        self::assertSame(
            $platform->getClobTypeDeclarationSQL($offlineColumns['col_text']->toArray()),
            $platform->getClobTypeDeclarationSQL($onlineColumns['col_text']->toArray())
        );
        self::assertSame(
            $platform->getClobTypeDeclarationSQL($offlineColumns['col_mediumtext']->toArray()),
            $platform->getClobTypeDeclarationSQL($onlineColumns['col_mediumtext']->toArray())
        );
        self::assertSame(
            $platform->getClobTypeDeclarationSQL($offlineColumns['col_longtext']->toArray()),
            $platform->getClobTypeDeclarationSQL($onlineColumns['col_longtext']->toArray())
        );

        self::assertSame(
            $platform->getBlobTypeDeclarationSQL($offlineColumns['col_tinyblob']->toArray()),
            $platform->getBlobTypeDeclarationSQL($onlineColumns['col_tinyblob']->toArray())
        );
        self::assertSame(
            $platform->getBlobTypeDeclarationSQL($offlineColumns['col_blob']->toArray()),
            $platform->getBlobTypeDeclarationSQL($onlineColumns['col_blob']->toArray())
        );
        self::assertSame(
            $platform->getBlobTypeDeclarationSQL($offlineColumns['col_mediumblob']->toArray()),
            $platform->getBlobTypeDeclarationSQL($onlineColumns['col_mediumblob']->toArray())
        );
        self::assertSame(
            $platform->getBlobTypeDeclarationSQL($offlineColumns['col_longblob']->toArray()),
            $platform->getBlobTypeDeclarationSQL($onlineColumns['col_longblob']->toArray())
        );
    }

    /**
     * @group DBAL-423
     */
    public function testDiffListGuidTableColumn()
    {
        $offlineTable = new Table('list_guid_table_column');
        $offlineTable->addColumn('col_guid', 'guid');

        $this->_sm->dropAndCreateTable($offlineTable);

        $onlineTable = $this->_sm->listTableDetails('list_guid_table_column');

        $comparator = new Comparator();

        self::assertFalse(
            $comparator->diffTable($offlineTable, $onlineTable),

            "No differences should be detected with the offline vs online schema."
        );
    }

    /**
     * @group DBAL-1082
     */
    public function testListDecimalTypeColumns()

    {
        $tableName = 'test_list_decimal_columns';
        $table = new Table($tableName);

        $table->addColumn('col', 'decimal');
        $table->addColumn('col_unsigned', 'decimal', array('unsigned' => true));

        $this->_sm->dropAndCreateTable($table);

        $columns = $this->_sm->listTableColumns($tableName);

        self::assertArrayHasKey('col', $columns);
        self::assertArrayHasKey('col_unsigned', $columns);
        self::assertFalse($columns['col']->getUnsigned());
        self::assertTrue($columns['col_unsigned']->getUnsigned());
    }

    /**
     * @group DBAL-1082
     */
    public function testListFloatTypeColumns()

    {
        $tableName = 'test_list_float_columns';
        $table = new Table($tableName);

        $table->addColumn('col', 'float');
        $table->addColumn('col_unsigned', 'float', array('unsigned' => true));

        $this->_sm->dropAndCreateTable($table);

        $columns = $this->_sm->listTableColumns($tableName);

        self::assertArrayHasKey('col', $columns);
        self::assertArrayHasKey('col_unsigned', $columns);
        self::assertFalse($columns['col']->getUnsigned());
        self::assertTrue($columns['col_unsigned']->getUnsigned());
    }

    /**
     * As of MariaDB 10.2.7, nullable default values literals are always single quoted in
     * information_schema. Non-nullable defaults behaviour is not affected.
     * This test ensure accidental removal of double single encoded defaults for MariaDB >= 10.2.7.
     *
     * @link https://mariadb.com/kb/en/library/information-schema-columns-table/
     * @link https://dev.mysql.com/doc/refman/5.5/en/string-literals.html
     */
    public function testColumnDefaultValuesDoubleQuoted() : void
    {
        $table = new Table("test_column_default_values_double_quoted");
        $table->addColumn('string_nullable_quoted', 'string', ['notnull' => false, 'default' => 'NULL']);
        $table->addColumn('string_nullable_double_quoted', 'string', ['notnull' => false, 'default' => "'NULL'"]);

        $table->addColumn('string_notnull_quoted', 'string', ['notnull' => true, 'default' => 'NULL']);
        $table->addColumn('string_notnull_double_quoted', 'string', ['notnull' => true, 'default' => "\\'NULL\\'"]);

        $this->_sm->dropAndCreateTable($table);

        $onlineTable = $this->_sm->listTableDetails("test_column_default_values_double_quoted");
        self::assertSame('NULL', $onlineTable->getColumn('string_nullable_quoted')->getDefault());

        self::assertSame("'NULL'", $onlineTable->getColumn('string_nullable_double_quoted')->getDefault());
        self::assertSame("NULL", $onlineTable->getColumn('string_notnull_quoted')->getDefault());
        self::assertSame("\\'NULL\\'", $onlineTable->getColumn('string_notnull_double_quoted')->getDefault());

        $comparator = new Comparator();

        $diff = $comparator->diffTable($table, $onlineTable);
        self::assertFalse($diff, "Tables should be identical with double quoted literals.");
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }

    /**
     * @link https://mariadb.com/kb/en/library/string-literals
     * @link https://dev.mysql.com/doc/refman/5.7/en/string-literals.html
     */
    public function testColumnEscapingDefaultValuesDoesNotTriggerSchemaChange() : void
    {
        $table = new Table("test_column_default_values_escaping");
        $table->addColumn('single_backslash', 'string', ['default' => 'F\Q\D\N']);
        $table->addColumn('double_backslash', 'string', ['default' => 'F\\Q\\D\\N']);
        $table->addColumn('triple_backslash', 'string', ['default' => 'a\\\z']);
        $table->addColumn('repeated_single_quotes', 'string', ['default' => "a''z"]);
        $table->addColumn('backslash_double_quote', 'string', ['default' => 'a\"z']);
        $table->addColumn('backslash_newline', 'string', ['default' => 'a\nz']);

        $this->_sm->dropAndCreateTable($table);

        $onlineTable = $this->_sm->listTableDetails("test_column_default_values_escaping");
        self::assertSame('F\Q\D\N', $onlineTable->getColumn('single_backslash')->getDefault());
        self::assertSame('F\\Q\\D\\N', $onlineTable->getColumn('double_backslash')->getDefault());
        self::assertSame('a\\\z', $onlineTable->getColumn('triple_backslash')->getDefault());
        self::assertSame("a''z", $onlineTable->getColumn('repeated_single_quotes')->getDefault());
        self::assertSame('a\"z', $onlineTable->getColumn('backslash_double_quote')->getDefault());
        self::assertSame('a\nz', $onlineTable->getColumn('backslash_newline')->getDefault());

        $comparator = new Comparator();

        $diff = $comparator->diffTable($table, $onlineTable);
        self::assertFalse($diff, "Tables should be identical with values escape sequences.");
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }

    public function testJsonColumnType() : void
    {
        $platform = $this->_sm->getDatabasePlatform();
        if (!$platform->hasNativeJsonType()) {
            $this->markTestSkipped("Requires native JSON type");
        }

        $table = new Table('test_mysql_json');
        $table->addColumn('col_json', 'json');
        $this->_sm->dropAndCreateTable($table);

        $columns = $this->_sm->listTableColumns('test_mysql_json');

        self::assertSame(TYPE::JSON, $columns['col_json']->getType()->getName());
    }

    /**
     * Ensure that a table created outside doctrine and containing
     * quoted default values does not trigger a table diff change. I
     * Note: MariaDb 10.2 silently change "\'" into "''" when storing in
     * information schema, MariaDb102Platform should normalize the table details.
     */
    public function testExistingTableWithQuotedDefaultsDoesNotTriggerChange() : void
    {
        $this->_conn->query('DROP TABLE IF EXISTS test_column_defaults_with_create');
        $sql = "
            CREATE TABLE test_column_defaults_with_create (
                col1 VARCHAR(255) NULL DEFAULT 'O''Connor\'\"',              
                col2 VARCHAR(255) NOT NULL DEFAULT 'O''Connor\'\"'                                
                );
        ";
        $this->_conn->query($sql);

        $onlineTable = $this->_sm->listTableDetails("test_column_defaults_with_create");
        self::assertSame("O'Connor'\"", $onlineTable->getColumn('col1')->getDefault());
        self::assertSame("O'Connor'\"", $onlineTable->getColumn('col2')->getDefault());

        $table = new Table("test_column_defaults_no_diff");
        $table->addColumn('col1', 'string', ['notnull' => false, 'default' => "O'Connor'\""]);
        $table->addColumn('col2', 'string', ['notnull' => true, 'default' => "O'Connor'\""]);

        $comparator = new Comparator();
        $diff = $comparator->diffTable($table, $onlineTable);
        self::assertFalse($diff);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }

    public function testColumnDefaultCurrentTimestamp() : void
    {
        $platform = $this->_sm->getDatabasePlatform();

        $table = new Table("test_column_defaults_current_timestamp");

        $currentTimeStampSql = $platform->getCurrentTimestampSQL();

        $table->addColumn('col_datetime', 'datetime', ['notnull' => true, 'default' => $currentTimeStampSql]);
        $table->addColumn('col_datetime_nullable', 'datetime', ['default' => $currentTimeStampSql]);

        $this->_sm->dropAndCreateTable($table);

        $onlineTable = $this->_sm->listTableDetails("test_column_defaults_current_timestamp");
        self::assertSame($currentTimeStampSql, $onlineTable->getColumn('col_datetime')->getDefault());
        self::assertSame($currentTimeStampSql, $onlineTable->getColumn('col_datetime_nullable')->getDefault());

        $comparator = new Comparator();

        $diff = $comparator->diffTable($table, $onlineTable);
        self::assertFalse($diff, "Tables should be identical with column defaults.");
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }

    public function testColumnDefaultsAreValid() {

        $table = new Table("test_column_defaults_are_valid");

        $currentTimeStampSql = $this->_sm->getDatabasePlatform()->getCurrentTimestampSQL();
        $table->addColumn('col_datetime', 'datetime', ['default' => $currentTimeStampSql]);
        $table->addColumn('col_datetime_null', 'datetime', ['notnull' => false, 'default' => null]);
        $table->addColumn('col_int', 'integer', ['default' => 1]);
        $table->addColumn('col_neg_int', 'integer', ['default' => -1]);
        $table->addColumn('col_string', 'string', ['default' => 'A']);
        $table->addColumn('col_decimal', 'decimal', ['scale' => 3, 'precision' => 6, 'default' => -2.3]);
        $table->addColumn('col_date', 'date', ['default' => '2012-12-12']);

        $this->_sm->dropAndCreateTable($table);

        $this->_conn->executeUpdate(
            "INSERT INTO test_column_defaults_are_valid () VALUES()"
        );

        $row = $this->_conn->fetchAssoc(
            'SELECT *, DATEDIFF(CURRENT_TIMESTAMP(), col_datetime) as diff_seconds FROM test_column_defaults_are_valid'
        );

        self::assertInstanceOf(\DateTime::class, \DateTime::createFromFormat('Y-m-d H:i:s', $row['col_datetime']));
        self::assertNull($row['col_datetime_null']);
        self::assertSame('2012-12-12', $row['col_date']);
        self::assertSame('A', $row['col_string']);
        self::assertEquals(1, $row['col_int']);
        self::assertEquals(-1, $row['col_neg_int']);
        self::assertEquals('-2.300', $row['col_decimal']);
        self::assertLessThan(5, $row['diff_seconds']);
    }

    /**
     * MariaDB 10.2+ does support CURRENT_TIME and CURRENT_DATE as
     * column default values for time and date columns.
     * (Not supported on Mysql as of 5.7.19)
     *
     * Note that MariaDB 10.2+, when storing default in information_schema,
     * silently change CURRENT_TIMESTAMP as 'current_timestamp()',
     * CURRENT_TIME as 'currtime()' and CURRENT_DATE as 'currdate()'.
     * This test also ensure proper aliasing to not trigger a table diff.
     */
    public function testColumnDefaultValuesCurrentTimeAndDate() : void
    {
        if (!$this->_sm->getDatabasePlatform() instanceof MariaDb1027Platform) {
            $this->markTestSkipped('Only relevant for MariaDb102Platform.');
        }

        $platform = $this->_sm->getDatabasePlatform();

        $table = new Table("test_column_defaults_current_time_and_date");

        $currentTimestampSql = $platform->getCurrentTimestampSQL();
        $currentTimeSql = $platform->getCurrentTimeSQL();
        $currentDateSql = $platform->getCurrentDateSQL();

        $table->addColumn('col_datetime', 'datetime', ['default' => $currentTimestampSql]);
        $table->addColumn('col_date', 'date', ['default' => $currentDateSql]);
        $table->addColumn('col_time', 'time', ['default' => $currentTimeSql]);

        $this->_sm->dropAndCreateTable($table);

        $onlineTable = $this->_sm->listTableDetails("test_column_defaults_current_time_and_date");

        self::assertSame($currentTimestampSql, $onlineTable->getColumn('col_datetime')->getDefault());
        self::assertSame($currentDateSql, $onlineTable->getColumn('col_date')->getDefault());
        self::assertSame($currentTimeSql, $onlineTable->getColumn('col_time')->getDefault());

        $comparator = new Comparator();

        $diff = $comparator->diffTable($table, $onlineTable);
        self::assertFalse($diff, "Tables should be identical with column defauts time and date.");
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }

    /**
     * Since MariaDB 10.2.1, Blob and text columns can have a default value
     *
     * @link https://mariadb.com/kb/en/library/blob-and-text-data-types
     */
    public function testDoesPropagateDefaultValuesForBlobTextAndJson() : void
    {
        if (!$this->_sm->getDatabasePlatform() instanceof MariaDb1027Platform) {
            $this->markTestSkipped('Only relevant for MariaDb102Platform.');
        }

        $table = new Table("text_blob_default_value");

        $json = json_encode(['prop1' => "O'Connor", 'prop2' => 10]);

        $table->addColumn('def_text', 'text', ['default' => "O'Connor"]);
        $table->addColumn('def_text_null', 'text', ['notnull' => false, 'default' => 'def']);
        $table->addColumn('def_blob', 'blob', ['default' => '\F\Q\D\N']);
        $table->addColumn('def_json', 'json', ['default' => $json]);

        $this->_sm->dropAndCreateTable($table);

        $onlineTable = $this->_sm->listTableDetails("text_blob_default_value");

        self::assertSame("O'Connor", $onlineTable->getColumn('def_text')->getDefault());
        self::assertSame('def', $onlineTable->getColumn('def_text_null')->getDefault());
        self::assertSame('\F\Q\D\N', $onlineTable->getColumn('def_blob')->getDefault());
        self::assertSame($json, $onlineTable->getColumn('def_json')->getDefault());

        $comparator = new Comparator();

        self::assertFalse($comparator->diffTable($table, $onlineTable));

    }
}

1			<?php
2
3			namespace Doctrine\Tests\DBAL\Functional\Schema;
4
5			use Doctrine\DBAL\Platforms\MariaDb1027Platform;
6			use Doctrine\DBAL\Platforms\MySqlPlatform;
7			use Doctrine\DBAL\Schema\Comparator;
8			use Doctrine\DBAL\Schema\Schema;
9			use Doctrine\DBAL\Schema\Table;
10			use Doctrine\DBAL\Types\Type;
11			use Doctrine\Tests\Types\MySqlPointType;
12
13			class MySqlSchemaManagerTest extends SchemaManagerFunctionalTestCase
14			{
15
16			protected function setUp()
17			{
18			parent::setUp();
19
20			if (!Type::hasType('point')) {
21			Type::addType('point', MySqlPointType::class);
22			}
23			}
24
25			public function testSwitchPrimaryKeyColumns()
26			{
27			$tableOld = new Table("switch_primary_key_columns");
28			$tableOld->addColumn('foo_id', 'integer');
29			$tableOld->addColumn('bar_id', 'integer');
30
31			$this->_sm->createTable($tableOld);
32			$tableFetched = $this->_sm->listTableDetails("switch_primary_key_columns");
33			$tableNew = clone $tableFetched;
34			$tableNew->setPrimaryKey(array('bar_id', 'foo_id'));
35
36			$comparator = new Comparator;
37			$this->_sm->alterTable($comparator->diffTable($tableFetched, $tableNew));
			0 ignored issues – show Security Bug introduced 2017-06-29 19:35 UTC by Report Bug Copy Issue Report It seems like `$comparator->diffTable($tableFetched, $tableNew)` targeting `Doctrine\DBAL\Schema\Comparator::diffTable()` can also be of type `false`; however, `Doctrine\DBAL\Schema\Abs...maManager::alterTable()` does only seem to accept `object<Doctrine\DBAL\Schema\TableDiff>`, did you maybe forget to handle an error condition? Loading history...
38
39			$table = $this->_sm->listTableDetails('switch_primary_key_columns');
doctrine / dbal

Pull Request — master (#2825)

testColumnDefaultValuesCurrentTimeAndDate() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
