MySqlSchemaManagerTest::testColumnDefaultsUsingSql() - Code Metrics - Inspection of "Fix mariadb 10.2.7 default column values (nulls to..." - doctrine/dbal - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Pull Request — master (#2825)

by Sébastien

created 2017-09-12 16:08 UTC

testColumnDefaultsUsingSql() B

↳ Parent: MySqlSchemaManagerTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	39
Code Lines	18

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	39
rs	8.8571
cc	1
eloc	18
nc	1
nop	0

<?php

namespace Doctrine\Tests\DBAL\Functional\Schema;

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;

class MySqlSchemaManagerTest extends SchemaManagerFunctionalTestCase
{
    protected function setUp()
    {
        parent::setUp();

        if (!Type::hasType('point')) {
            Type::addType('point', 'Doctrine\Tests\Types\MySqlPointType');
        }
    }

    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()
    {
        $table = new Table("text_blob_default_value");
        $table->addColumn('def_text', 'text', array('default' => 'def'));
        $table->addColumn('def_text_null', 'text', array('notnull' => false, 'default' => 'def'));
        $table->addColumn('def_blob', 'blob', array('default' => 'def'));
        $table->addColumn('def_blob_null', 'blob', array('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());
    }

    public function testColumnDefaultsUsingDoctrineTable(): void
    {

        $table = new Table("test_column_defaults_with_table");
        $table->addColumn('col0', 'integer', ['notnull' => false]);
        $table->addColumn('col1', 'integer', ['notnull' => false, 'default' => null]);
        $table->addColumn('col2', 'string', ['notnull' => false, 'default' => null]);
        $table->addColumn('col3', 'string', ['notnull' => false, 'default' => 'NULL']);
        $table->addColumn('col4', 'string', ['notnull' => false, 'default' => 'Hello world']);
        $table->addColumn('col5', 'datetime', ['notnull' => false, 'default' => null]);
        $table->addColumn('col6', 'decimal', ['scale' => 3, 'precision' => 6, 'notnull' => false, 'default' => -2.3]);
        $table->addColumn('col7', 'date', ['notnull' => false, 'default' => '2012-12-12']);
        $table->addColumn('col8', 'string', ['notnull' => true, 'default' => '']);
        $table->addColumn('col9', 'integer', ['notnull' => false, 'default' => 0]);
        $table->addColumn('col10', 'string', ['notnull' => false, 'default' => 'He"ll"o world']);

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

        $onlineTable = $this->_sm->listTableDetails("test_column_defaults_with_table");
        self::assertNull($onlineTable->getColumn('col0')->getDefault());
        self::assertNull($onlineTable->getColumn('col1')->getDefault());
        self::assertNull($onlineTable->getColumn('col2')->getDefault());
        self::assertEquals('NULL', $onlineTable->getColumn('col3')->getDefault());
        self::assertEquals('Hello world', $onlineTable->getColumn('col4')->getDefault());
        self::assertNull($onlineTable->getColumn('col5')->getDefault());
        self::assertEquals(-2.3, $onlineTable->getColumn('col6')->getDefault());
        self::assertEquals('2012-12-12', $onlineTable->getColumn('col7')->getDefault());
        self::assertTrue($onlineTable->getColumn('col8')->getNotnull());
        self::assertEquals('', $onlineTable->getColumn('col8')->getDefault());
        self::assertEquals(0, $onlineTable->getColumn('col9')->getDefault());
        self::assertEquals('He"ll"o world', $onlineTable->getColumn('col10')->getDefault());

        $comparator = new Comparator();

        $diff = $comparator->diffTable($table, $onlineTable);
        $this->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 testColumnDefaultsUsingSql(): void
    {

        $this->_conn->query('DROP TABLE IF EXISTS `test_column_defaults_with_create`');
        $sql = sprintf("
            CREATE TABLE `test_column_defaults_with_create` (
                `col0` INT(11) NULL,
                `col1` INT(10) UNSIGNED NULL DEFAULT NULL,
                `col2` VARCHAR(10) CHARACTER SET UTF8MB4 COLLATE UTF8MB4_GENERAL_CI NULL DEFAULT NULL,
                `col3` VARCHAR(10) CHARACTER SET UTF8MB4 COLLATE UTF8MB4_GENERAL_CI NULL DEFAULT 'NULL',
                `col4` VARCHAR(20) NULL DEFAULT 'Hello world',
                `col5` DATETIME NULL DEFAULT NULL,
                `col6` DECIMAL(6, 3) NULL DEFAULT -2.3,
                `col7` DATE NULL DEFAULT '2012-12-12',
                `col8` VARCHAR(20) NOT NULL DEFAULT '',
                `col9` INT(11) NULL DEFAULT 0,
                `col10` VARCHAR(20) NULL DEFAULT '%s'                                                
                ) ENGINE=INNODB;
        ", 'He"ll"o world');

        $this->_conn->query($sql);
        $t = $this->_sm->listTableDetails("test_column_defaults_with_create");
        self::assertNull($t->getColumn('col0')->getDefault());
        self::assertNull($t->getColumn('col1')->getDefault());
        self::assertNull($t->getColumn('col2')->getDefault());
        self::assertEquals('NULL', $t->getColumn('col3')->getDefault());
        self::assertEquals('Hello world', $t->getColumn('col4')->getDefault());
        self::assertNull($t->getColumn('col5')->getDefault());
        self::assertEquals(-2.3, $t->getColumn('col6')->getDefault());
        self::assertEquals('2012-12-12', $t->getColumn('col7')->getDefault());
        self::assertTrue($t->getColumn('col8')->getNotnull());
        self::assertEquals('', $t->getColumn('col8')->getDefault());
        self::assertEquals(0, $t->getColumn('col9')->getDefault());
        self::assertEquals('He"ll"o world', $t->getColumn('col10')->getDefault());

        // @todo mariadb returns 'current_timestamp()'
        //   `col10` DATETIME NULL DEFAULT CURRENT_TIMESTAMP
        //    $this->assertEquals('current_timestamp', strtolower($t->getColumn('col10')->getDefault()));

    }

}


1			<?php
2
3			namespace Doctrine\Tests\DBAL\Functional\Schema;
4
5			use Doctrine\DBAL\Platforms\MySqlPlatform;
6			use Doctrine\DBAL\Schema\Comparator;
7			use Doctrine\DBAL\Schema\Schema;
8			use Doctrine\DBAL\Schema\Table;
9			use Doctrine\DBAL\Types\Type;
10
11			class MySqlSchemaManagerTest extends SchemaManagerFunctionalTestCase
12			{
13			protected function setUp()
14			{
15			parent::setUp();
16
17			if (!Type::hasType('point')) {
18			Type::addType('point', 'Doctrine\Tests\Types\MySqlPointType');
19			}
20			}
21
22			public function testSwitchPrimaryKeyColumns()
23			{
24			$tableOld = new Table("switch_primary_key_columns");
25			$tableOld->addColumn('foo_id', 'integer');
26			$tableOld->addColumn('bar_id', 'integer');
27
28			$this->_sm->createTable($tableOld);
29			$tableFetched = $this->_sm->listTableDetails("switch_primary_key_columns");
30			$tableNew = clone $tableFetched;
31			$tableNew->setPrimaryKey(array('bar_id', 'foo_id'));
32
33			$comparator = new Comparator;
34			$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...
35
36			$table = $this->_sm->listTableDetails('switch_primary_key_columns');
37			$primaryKey = $table->getPrimaryKeyColumns();
38
39			self::assertCount(2, $primaryKey);

doctrine / dbal

Pull Request — master (#2825)

testColumnDefaultsUsingSql() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like