Proyectos de Subversion Moodle

<?php

// This file is part of Moodle - http://moodle.org/

//

// Moodle is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// Moodle is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

namespace core;

use database_column_info;

use moodle_database;

use sql_generator;

use xmldb_field;

use xmldb_index;

use xmldb_key;

use xmldb_structure;

use xmldb_table;

/**

 * DDL layer tests.

 *

 * @package    core_ddl

 * @category   test

 * @copyright  2008 Nicolas Connault

 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

class ddl_test extends \database_driver_testcase {

    /** @var xmldb_table[] keys are table name. Created in setUp. */

    private $tables = array();

    /** @var array table name => array of stdClass test records loaded into that table. Created in setUp. */

    private $records = array();

    protected function setUp(): void {

        parent::setUp();

        $dbman = $this->tdb->get_manager(); // Loads DDL libs.

        $table = new xmldb_table('test_table0');

        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);

        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');

        $table->add_field('type', XMLDB_TYPE_CHAR, '20', null, XMLDB_NOTNULL, null, 'general');

        $table->add_field('name', XMLDB_TYPE_CHAR, '255', null, XMLDB_NOTNULL, null);

        $table->add_field('intro', XMLDB_TYPE_TEXT, 'small', null, XMLDB_NOTNULL, null, null);

        $table->add_field('logo', XMLDB_TYPE_BINARY, 'big', null, null, null);

        $table->add_field('assessed', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');

        $table->add_field('assesstimestart', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');

        $table->add_field('assesstimefinish', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');

        $table->add_field('scale', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');

        $table->add_field('maxbytes', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');

        $table->add_field('forcesubscribe', XMLDB_TYPE_INTEGER, '1', null, XMLDB_NOTNULL, null, '0');

        $table->add_field('trackingtype', XMLDB_TYPE_INTEGER, '2', null, XMLDB_NOTNULL, null, '1');

        $table->add_field('rsstype', XMLDB_TYPE_INTEGER, '2', null, XMLDB_NOTNULL, null, '0');

        $table->add_field('rssarticles', XMLDB_TYPE_INTEGER, '2', null, XMLDB_NOTNULL, null, '0');

        $table->add_field('timemodified', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');

        $table->add_field('grade', XMLDB_TYPE_NUMBER, '20,0', null, null, null, null);

        $table->add_field('percent', XMLDB_TYPE_NUMBER, '5,2', null, null, null, 66.6);

        $table->add_field('bignum', XMLDB_TYPE_NUMBER, '38,18', null, null, null, 1234567890.1234);

        $table->add_field('warnafter', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');

        $table->add_field('blockafter', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');

        $table->add_field('blockperiod', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');

        $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));

        $table->add_key('course', XMLDB_KEY_UNIQUE, array('course'));

        $table->add_index('type-name', XMLDB_INDEX_UNIQUE, array('type', 'name'));

        $table->add_index('rsstype', XMLDB_INDEX_NOTUNIQUE, array('rsstype'));

        $table->setComment("This is a test'n drop table. You can drop it safely");

        $this->tables[$table->getName()] = $table;

        // Define 2 initial records for this table.

        $this->records[$table->getName()] = array(

            (object)array(

                'course' => '1',

                'type'   => 'general',

                'name'   => 'record',

                'intro'  => 'first record'),

            (object)array(

                'course' => '2',

                'type'   => 'social',

                'name'   => 'record',

                'intro'  => 'second record'));

        // Second, smaller table.

        $table = new xmldb_table ('test_table1');

        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);

        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');

        $table->add_field('name', XMLDB_TYPE_CHAR, '30', null, null, null, 'Moodle');

        $table->add_field('secondname', XMLDB_TYPE_CHAR, '30', null, XMLDB_NOTNULL, null, null);

        $table->add_field('thirdname', XMLDB_TYPE_CHAR, '30', null, null, null, ''); // Nullable column with empty default.

        $table->add_field('intro', XMLDB_TYPE_TEXT, 'medium', null, XMLDB_NOTNULL, null, null);

        $table->add_field('avatar', XMLDB_TYPE_BINARY, 'medium', null, null, null, null);

        $table->add_field('grade', XMLDB_TYPE_NUMBER, '20,10', null, null, null);

        $table->add_field('gradefloat', XMLDB_TYPE_FLOAT, '20,0', null, null, null, null);

        $table->add_field('percentfloat', XMLDB_TYPE_FLOAT, '5,2', null, null, null, 99.9);

        $table->add_field('userid', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');

        $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));

        $table->add_key('course', XMLDB_KEY_FOREIGN_UNIQUE, array('course'), 'test_table0', array('course'));

        $table->setComment("This is a test'n drop table. You can drop it safely");

        $this->tables[$table->getName()] = $table;

        // Define 2 initial records for this table.

        $this->records[$table->getName()] = array(

            (object)array(

                'course' => '1',

                'secondname'   => 'first record', // Less than 10 cc, please don't modify. Some tests below depend of this.

                'intro'  => 'first record'),

            (object)array(

                'course'       => '2',

                'secondname'   => 'second record', // More than 10 cc, please don't modify. Some tests below depend of this.

                'intro'  => 'second record'));

    }

    private function create_deftable($tablename) {

        $dbman = $this->tdb->get_manager();

        if (!isset($this->tables[$tablename])) {

            return null;

        }

        $table = $this->tables[$tablename];

        if ($dbman->table_exists($table)) {

            $dbman->drop_table($table);

        }

        $dbman->create_table($table);

        return $table;

    }

    /**

     * Fill the given test table with some records, as far as

     * DDL behaviour must be tested both with real data and

     * with empty tables

     * @param string $tablename

     * @return int count of records

     */

    private function fill_deftable($tablename) {

        $DB = $this->tdb; // Do not use global $DB!

        $dbman = $this->tdb->get_manager();

        if (!isset($this->records[$tablename])) {

            return null;

        }

        if ($dbman->table_exists($tablename)) {

            foreach ($this->records[$tablename] as $row) {

                $DB->insert_record($tablename, $row);

            }

        } else {

            return null;

        }

        return count($this->records[$tablename]);

    }

    /**

     * Test behaviour of table_exists()

     */

    public function test_table_exists(): void {

        $DB = $this->tdb; // Do not use global $DB!

        $dbman = $this->tdb->get_manager();

        // First make sure it returns false if table does not exist.

        $table = $this->tables['test_table0'];

        try {

            $result = $DB->get_records('test_table0');

        } catch (\dml_exception $e) {

            $result = false;

        }

        $this->resetDebugging();

        $this->assertFalse($result);

        $this->assertFalse($dbman->table_exists('test_table0')); // By name..

        $this->assertFalse($dbman->table_exists($table));        // By xmldb_table..

        // Create table and test again.

        $dbman->create_table($table);

        $this->assertSame(array(), $DB->get_records('test_table0'));

        $this->assertTrue($dbman->table_exists('test_table0')); // By name.

        $this->assertTrue($dbman->table_exists($table));        // By xmldb_table.

        // Drop table and test again.

        $dbman->drop_table($table);

        try {

            $result = $DB->get_records('test_table0');

        } catch (\dml_exception $e) {

            $result = false;

        }

        $this->resetDebugging();

        $this->assertFalse($result);

        $this->assertFalse($dbman->table_exists('test_table0')); // By name.

        $this->assertFalse($dbman->table_exists($table));        // By xmldb_table.

    }

    /**

     * Test behaviour of create_table()

     */

    public function test_create_table(): void {

        $DB = $this->tdb; // Do not use global $DB!

        $dbman = $this->tdb->get_manager();

        // Create table.

        $table = $this->tables['test_table1'];

        $dbman->create_table($table);

        $this->assertTrue($dbman->table_exists($table));

        // Basic get_tables() test.

        $tables = $DB->get_tables();

        $this->assertArrayHasKey('test_table1', $tables);

        // Basic get_columns() tests.

        $columns = $DB->get_columns('test_table1');

        $this->assertSame('R', $columns['id']->meta_type);

        $this->assertSame('I', $columns['course']->meta_type);

        $this->assertSame('C', $columns['name']->meta_type);

        $this->assertSame('C', $columns['secondname']->meta_type);

        $this->assertSame('C', $columns['thirdname']->meta_type);

        $this->assertSame('X', $columns['intro']->meta_type);

        $this->assertSame('B', $columns['avatar']->meta_type);

        $this->assertSame('N', $columns['grade']->meta_type);

        $this->assertSame('N', $columns['percentfloat']->meta_type);

        $this->assertSame('I', $columns['userid']->meta_type);

        // Some defaults.

        $this->assertTrue($columns['course']->has_default);

        $this->assertEquals(0, $columns['course']->default_value);

        $this->assertTrue($columns['name']->has_default);

        $this->assertSame('Moodle', $columns['name']->default_value);

        $this->assertTrue($columns['secondname']->has_default);

        $this->assertSame('', $columns['secondname']->default_value);

        $this->assertTrue($columns['thirdname']->has_default);

        $this->assertSame('', $columns['thirdname']->default_value);

        $this->assertTrue($columns['percentfloat']->has_default);

        $this->assertEquals(99.9, $columns['percentfloat']->default_value);

        $this->assertTrue($columns['userid']->has_default);

        $this->assertEquals(0, $columns['userid']->default_value);

        // Basic get_indexes() test.

        $indexes = $DB->get_indexes('test_table1');

        $courseindex = reset($indexes);

        $this->assertEquals(1, $courseindex['unique']);

        $this->assertSame('course', $courseindex['columns'][0]);

        // Check sequence returns 1 for first insert.

        $rec = (object)array(

            'course'     => 10,

            'secondname' => 'not important',

            'intro'      => 'not important');

        $this->assertSame(1, $DB->insert_record('test_table1', $rec));

        // Check defined defaults are working ok.

        $dbrec = $DB->get_record('test_table1', array('id' => 1));

        $this->assertSame('Moodle', $dbrec->name);

        $this->assertSame('', $dbrec->thirdname);

        // Check exceptions if multiple R columns.

        $table = new xmldb_table ('test_table2');

        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);

        $table->add_field('rid', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);

        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');

        $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));

        $table->add_key('primaryx', XMLDB_KEY_PRIMARY, array('id'));

        $table->setComment("This is a test'n drop table. You can drop it safely");

        $this->tables[$table->getName()] = $table;

        try {

            $dbman->create_table($table);

            $this->fail('Exception expected');

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('ddl_exception', $e);

        }

        // Check exceptions missing primary key on R column.

        $table = new xmldb_table ('test_table2');

        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);

        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');

        $table->setComment("This is a test'n drop table. You can drop it safely");

        $this->tables[$table->getName()] = $table;

        try {

            $dbman->create_table($table);

            $this->fail('Exception expected');

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('ddl_exception', $e);

        }

        // Long table name names - the largest allowed by the configuration which exclude the prefix to ensure it's created.

        $tablechars = str_repeat('a', xmldb_table::NAME_MAX_LENGTH);

        $table = new xmldb_table($tablechars);

        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);

        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '2');

        $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));

        $table->setComment("This is a test'n drop table. You can drop it safely");

        $this->tables[$table->getName()] = $table;

        $dbman->create_table($table);

        $this->assertTrue($dbman->table_exists($table));

        $dbman->drop_table($table);

        // Table name is too long, ignoring any prefix size set.

        $tablechars = str_repeat('a', xmldb_table::NAME_MAX_LENGTH + 1);

        $table = new xmldb_table($tablechars);

        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);

        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '2');

        $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));

        $table->setComment("This is a test'n drop table. You can drop it safely");

        $this->tables[$table->getName()] = $table;

        try {

            $dbman->create_table($table);

            $this->fail('Exception expected');

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('coding_exception', $e);

        }

        // Invalid table name.

        $table = new xmldb_table('test_tableCD');

        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);

        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '2');

        $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));

        $table->setComment("This is a test'n drop table. You can drop it safely");

        $this->tables[$table->getName()] = $table;

        try {

            $dbman->create_table($table);

            $this->fail('Exception expected');

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('coding_exception', $e);

        }

        // Weird column names - the largest allowed.

        $table = new xmldb_table('test_table3');

        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);

        $table->add_field(str_repeat('b', xmldb_field::NAME_MAX_LENGTH), XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '2');

        $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));

        $table->setComment("This is a test'n drop table. You can drop it safely");

        $this->tables[$table->getName()] = $table;

        $dbman->create_table($table);

        $this->assertTrue($dbman->table_exists($table));

        $dbman->drop_table($table);

        // Too long field name.

        $table = new xmldb_table('test_table4');

        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);

        $table->add_field(str_repeat('a', xmldb_field::NAME_MAX_LENGTH + 1), XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '2');

        $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));

        $table->setComment("This is a test'n drop table. You can drop it safely");

        $this->tables[$table->getName()] = $table;

        try {

            $dbman->create_table($table);

            $this->fail('Exception expected');

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('coding_exception', $e);

        }

        // Invalid field name.

        $table = new xmldb_table('test_table4');

        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);

        $table->add_field('abCD', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '2');

        $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));

        $table->setComment("This is a test'n drop table. You can drop it safely");

        $this->tables[$table->getName()] = $table;

        try {

            $dbman->create_table($table);

            $this->fail('Exception expected');

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('coding_exception', $e);

        }

        // Invalid integer length.

        $table = new xmldb_table('test_table4');

        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);

        $table->add_field('course', XMLDB_TYPE_INTEGER, '21', null, XMLDB_NOTNULL, null, '2');

        $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));

        $table->setComment("This is a test'n drop table. You can drop it safely");

        $this->tables[$table->getName()] = $table;

        try {

            $dbman->create_table($table);

            $this->fail('Exception expected');

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('coding_exception', $e);

        }

        // Invalid integer default.

        $table = new xmldb_table('test_table4');

        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);

        $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, 'x');

        $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));

        $table->setComment("This is a test'n drop table. You can drop it safely");

        $this->tables[$table->getName()] = $table;

        try {

            $dbman->create_table($table);

            $this->fail('Exception expected');

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('coding_exception', $e);

        }

        // Invalid decimal length - max precision is 38 digits.

        $table = new xmldb_table('test_table4');

        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);

        $table->add_field('num', XMLDB_TYPE_NUMBER, '39,19', null, XMLDB_NOTNULL, null, null);

        $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));

        $table->setComment("This is a test'n drop table. You can drop it safely");

        $this->tables[$table->getName()] = $table;

        try {

            $dbman->create_table($table);

            $this->fail('Exception expected');

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('coding_exception', $e);

        }

        // Invalid decimal decimals - number of decimals can't be higher than total number of digits.

        $table = new xmldb_table('test_table4');

        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);

        $table->add_field('num', XMLDB_TYPE_NUMBER, '10,11', null, XMLDB_NOTNULL, null, null);

        $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));

        $table->setComment("This is a test'n drop table. You can drop it safely");

        $this->tables[$table->getName()] = $table;

        try {

            $dbman->create_table($table);

            $this->fail('Exception expected');

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('coding_exception', $e);

        }

        // Invalid decimal whole number - the whole number part can't have more digits than integer fields.

        $table = new xmldb_table('test_table4');

        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);

        $table->add_field('num', XMLDB_TYPE_NUMBER, '38,17', null, XMLDB_NOTNULL, null, null);

        $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));

        $table->setComment("This is a test'n drop table. You can drop it safely");

        $this->tables[$table->getName()] = $table;

        try {

            $dbman->create_table($table);

            $this->fail('Exception expected');

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('coding_exception', $e);

        }

        // Invalid decimal decimals - negative scale not supported.

        $table = new xmldb_table('test_table4');

        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);

        $table->add_field('num', XMLDB_TYPE_NUMBER, '30,-5', null, XMLDB_NOTNULL, null, null);

        $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));

        $table->setComment("This is a test'n drop table. You can drop it safely");

        $this->tables[$table->getName()] = $table;

        try {

            $dbman->create_table($table);

            $this->fail('Exception expected');

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('coding_exception', $e);

        }

        // Invalid decimal default.

        $table = new xmldb_table('test_table4');

        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);

        $table->add_field('num', XMLDB_TYPE_NUMBER, '10,5', null, XMLDB_NOTNULL, null, 'x');

        $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));

        $table->setComment("This is a test'n drop table. You can drop it safely");

        $this->tables[$table->getName()] = $table;

        try {

            $dbman->create_table($table);

            $this->fail('Exception expected');

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('coding_exception', $e);

        }

        // Invalid float length.

        $table = new xmldb_table('test_table4');

        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);

        $table->add_field('num', XMLDB_TYPE_FLOAT, '21,10', null, XMLDB_NOTNULL, null, null);

        $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));

        $table->setComment("This is a test'n drop table. You can drop it safely");

        $this->tables[$table->getName()] = $table;

        try {

            $dbman->create_table($table);

            $this->fail('Exception expected');

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('coding_exception', $e);

        }

        // Invalid float decimals.

        $table = new xmldb_table('test_table4');

        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);

        $table->add_field('num', XMLDB_TYPE_FLOAT, '10,11', null, XMLDB_NOTNULL, null, null);

        $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));

        $table->setComment("This is a test'n drop table. You can drop it safely");

        $this->tables[$table->getName()] = $table;

        try {

            $dbman->create_table($table);

            $this->fail('Exception expected');

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('coding_exception', $e);

        }

        // Invalid float default.

        $table = new xmldb_table('test_table4');

        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);

        $table->add_field('num', XMLDB_TYPE_FLOAT, '10,5', null, XMLDB_NOTNULL, null, 'x');

        $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));

        $table->setComment("This is a test'n drop table. You can drop it safely");

        $this->tables[$table->getName()] = $table;

        try {

            $dbman->create_table($table);

            $this->fail('Exception expected');

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('coding_exception', $e);

        }

    }

    /**

     * Test if database supports tables with many TEXT fields,

     * InnoDB is known to failed during data insertion instead

     * of table creation when text fields contain actual data.

     */

    public function test_row_size_limits(): void {

        $DB = $this->tdb; // Do not use global $DB!

        $dbman = $this->tdb->get_manager();

        $text = str_repeat('š', 1333);

        $data = new \stdClass();

        $data->name = 'test';

        $table = new xmldb_table('test_innodb');

        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);

        $table->add_field('name', XMLDB_TYPE_CHAR, '30', null, null, null, null);

        $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));

        for ($i = 0; $i < 20; $i++) {

            $table->add_field('text'.$i, XMLDB_TYPE_TEXT, null, null, null, null, null);

            $data->{'text'.$i} = $text;

        }

        $dbman->create_table($table);

        try {

            $id = $DB->insert_record('test_innodb', $data);

            $expected = (array)$data;

            $expected['id'] = (string)$id;

            $this->assertEqualsCanonicalizing($expected, (array)$DB->get_record('test_innodb', array('id' => $id)));

        } catch (\dml_exception $e) {

            // Give some nice error message when known problematic MySQL with InnoDB detected.

            if ($DB->get_dbfamily() === 'mysql') {

                $engine = strtolower($DB->get_dbengine());

                if ($engine === 'innodb' or $engine === 'xtradb') {

                    if (!$DB->is_compressed_row_format_supported()) {

                        $this->fail("Row size limit reached in MySQL using InnoDB, configure server to use innodb_file_format=Barracuda and innodb_file_per_table=1");

                    }

                }

            }

            throw $e;

        }

        $dbman->drop_table($table);

        $data = new \stdClass();

        $data->name = 'test';

        $table = new xmldb_table('test_innodb');

        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);

        $table->add_field('name', XMLDB_TYPE_CHAR, '30', null, null, null, null);

        $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));

        $dbman->create_table($table);

        $DB->insert_record('test_innodb', array('name' => 'test'));

        for ($i = 0; $i < 20; $i++) {

            $field = new xmldb_field('text'.$i, XMLDB_TYPE_TEXT, null, null, null, null, null);

            $dbman->add_field($table, $field);

            $data->{'text'.$i} = $text;

            $id = $DB->insert_record('test_innodb', $data);

            $expected = (array)$data;

            $expected['id'] = (string)$id;

            $this->assertEqualsCanonicalizing($expected, (array)$DB->get_record('test_innodb', array('id' => $id)));

        }

        $dbman->drop_table($table);

        // MySQL VARCHAR fields may hit a different 65535 row size limit when creating tables.

        $data = new \stdClass();

        $data->name = 'test';

        $table = new xmldb_table('test_innodb');

        $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);

        $table->add_field('name', XMLDB_TYPE_CHAR, '30', null, null, null, null);

        $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));

        for ($i = 0; $i < 12; $i++) {

            $table->add_field('text'.$i, XMLDB_TYPE_CHAR, '1333', null, null, null, null);

            $data->{'text'.$i} = $text;

        }

        $dbman->create_table($table);

        $id = $DB->insert_record('test_innodb', $data);

        $expected = (array)$data;

        $expected['id'] = (string)$id;

        $this->assertEqualsCanonicalizing($expected, (array)$DB->get_record('test_innodb', array('id' => $id)));

        $dbman->drop_table($table);

    }

    /**

     * Test behaviour of drop_table()

     */

    public function test_drop_table(): void {

        $DB = $this->tdb; // Do not use global $DB!

        $dbman = $this->tdb->get_manager();

        // Initially table doesn't exist.

        $this->assertFalse($dbman->table_exists('test_table0'));

        // Create table with contents.

        $table = $this->create_deftable('test_table0');

        $this->assertTrue($dbman->table_exists('test_table0'));

        // Fill the table with some records before dropping it.

        $this->fill_deftable('test_table0');

        // Drop by xmldb_table object.

        $dbman->drop_table($table);

        $this->assertFalse($dbman->table_exists('test_table0'));

        // Basic get_tables() test.

        $tables = $DB->get_tables();

        $this->assertArrayNotHasKey('test_table0', $tables);

        // Columns cache must be empty.

        $columns = $DB->get_columns('test_table0');

        $this->assertEmpty($columns);

        $indexes = $DB->get_indexes('test_table0');

        $this->assertEmpty($indexes);

    }

    /**

     * Test behaviour of rename_table()

     */

    public function test_rename_table(): void {

        $DB = $this->tdb; // Do not use global $DB!

        $dbman = $this->tdb->get_manager();

        $table = $this->create_deftable('test_table1');

        // Fill the table with some records before renaming it.

        $insertedrows = $this->fill_deftable('test_table1');

        $this->assertFalse($dbman->table_exists('test_table_cust1'));

        $dbman->rename_table($table, 'test_table_cust1');

        $this->assertTrue($dbman->table_exists('test_table_cust1'));

        // Check sequence returns $insertedrows + 1 for this insert (after rename).

        $rec = (object)array(

            'course'     => 20,

            'secondname' => 'not important',

            'intro'      => 'not important');

        $this->assertSame($insertedrows+1, $DB->insert_record('test_table_cust1', $rec));

        // Verify behavior when target table already exists.

        $sourcetable = $this->create_deftable('test_table0');

        $targettable = $this->create_deftable('test_table1');

        try {

            $dbman->rename_table($sourcetable, $targettable->getName());

            $this->fail('Exception expected');

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('ddl_exception', $e);

            $this->assertEquals('Table "test_table1" already exists (can not rename table)', $e->getMessage());

        }

    }

    /**

     * Test behaviour of field_exists()

     */

    public function test_field_exists(): void {

        $dbman = $this->tdb->get_manager();

        $table = $this->create_deftable('test_table0');

        // String params.

        // Give a nonexistent table as first param (throw exception).

        try {

            $dbman->field_exists('nonexistenttable', 'id');

            $this->fail('Exception expected');

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('moodle_exception', $e);

        }

        // Give a nonexistent field as second param (return false).

        $this->assertFalse($dbman->field_exists('test_table0', 'nonexistentfield'));

        // Correct string params.

        $this->assertTrue($dbman->field_exists('test_table0', 'id'));

        // Object params.

        $realfield = $table->getField('id');

        // Give a nonexistent table as first param (throw exception).

        $nonexistenttable = new xmldb_table('nonexistenttable');

        try {

            $dbman->field_exists($nonexistenttable, $realfield);

            $this->fail('Exception expected');

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('moodle_exception', $e);

        }

        // Give a nonexistent field as second param (return false).

        $nonexistentfield = new xmldb_field('nonexistentfield');

        $this->assertFalse($dbman->field_exists($table, $nonexistentfield));

        // Correct object params.

        $this->assertTrue($dbman->field_exists($table, $realfield));

        // Mix string and object params.

        // Correct ones.

        $this->assertTrue($dbman->field_exists($table, 'id'));

        $this->assertTrue($dbman->field_exists('test_table0', $realfield));

        // Non existing tables (throw exception).

        try {

            $this->assertFalse($dbman->field_exists($nonexistenttable, 'id'));

            $this->fail('Exception expected');

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('moodle_exception', $e);

        }

        try {

            $this->assertFalse($dbman->field_exists('nonexistenttable', $realfield));

            $this->fail('Exception expected');

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('moodle_exception', $e);

        }

        // Non existing fields (return false).

        $this->assertFalse($dbman->field_exists($table, 'nonexistentfield'));

        $this->assertFalse($dbman->field_exists('test_table0', $nonexistentfield));

    }

    /**

     * Test behaviour of add_field()

     */

    public function test_add_field(): void {

        $DB = $this->tdb; // Do not use global $DB!

        $dbman = $this->tdb->get_manager();

        $table = $this->create_deftable('test_table1');

        // Fill the table with some records before adding fields.

        $this->fill_deftable('test_table1');

        // Add one not null field without specifying default value (throws ddl_exception).

        $field = new xmldb_field('onefield');

        $field->set_attributes(XMLDB_TYPE_INTEGER, '6', null, XMLDB_NOTNULL, null, null);

        try {

            $dbman->add_field($table, $field);

            $this->fail('Exception expected');

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('ddl_exception', $e);

        }

        // Add one existing field (throws ddl_exception).

        $field = new xmldb_field('course');

        $field->set_attributes(XMLDB_TYPE_INTEGER, '6', null, XMLDB_NOTNULL, null, 2);

        try {

            $dbman->add_field($table, $field);

            $this->fail('Exception expected');

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('ddl_exception', $e);

        }

        // TODO: add one field with invalid type, must throw exception.

        // TODO: add one text field with default, must throw exception.

        // TODO: add one binary field with default, must throw exception.

        // Add one integer field and check it.

        $field = new xmldb_field('oneinteger');

        $field->set_attributes(XMLDB_TYPE_INTEGER, '6', null, XMLDB_NOTNULL, null, 2);

        $dbman->add_field($table, $field);

        $this->assertTrue($dbman->field_exists($table, 'oneinteger'));

        $columns = $DB->get_columns('test_table1');

        $this->assertEquals('oneinteger', $columns['oneinteger']->name);

        $this->assertTrue($columns['oneinteger']->not_null);

        // Max_length and scale cannot be checked under all DBs at all for integer fields.

        $this->assertFalse($columns['oneinteger']->primary_key);

        $this->assertFalse($columns['oneinteger']->binary);

        $this->assertTrue($columns['oneinteger']->has_default);

        $this->assertEquals(2, $columns['oneinteger']->default_value);

        $this->assertSame('I', $columns['oneinteger']->meta_type);

        $this->assertEquals(2, $DB->get_field('test_table1', 'oneinteger', array(), IGNORE_MULTIPLE)); // Check default has been applied.

        // Add one numeric field and check it.

        $field = new xmldb_field('onenumber');

        $field->set_attributes(XMLDB_TYPE_NUMBER, '6,3', null, XMLDB_NOTNULL, null, 2.55);

        $dbman->add_field($table, $field);

        $this->assertTrue($dbman->field_exists($table, 'onenumber'));

        $columns = $DB->get_columns('test_table1');

        $this->assertSame('onenumber', $columns['onenumber']->name);

        $this->assertEquals(6, $columns['onenumber']->max_length);

        $this->assertEquals(3, $columns['onenumber']->scale);

        $this->assertTrue($columns['onenumber']->not_null);

        $this->assertFalse($columns['onenumber']->primary_key);

        $this->assertFalse($columns['onenumber']->binary);

        $this->assertTrue($columns['onenumber']->has_default);

        $this->assertEquals(2.550, $columns['onenumber']->default_value);

        $this->assertSame('N', $columns['onenumber']->meta_type);

        $this->assertEquals(2.550, $DB->get_field('test_table1', 'onenumber', array(), IGNORE_MULTIPLE)); // Check default has been applied.

        // Add one numeric field with scale of 0 and check it.

        $field = new xmldb_field('onenumberwith0scale');

        $field->set_attributes(XMLDB_TYPE_NUMBER, '6,0', null, XMLDB_NOTNULL, null, 2);

        $dbman->add_field($table, $field);

        $this->assertTrue($dbman->field_exists($table, 'onenumberwith0scale'));

        $columns = $DB->get_columns('test_table1');

        $this->assertEquals(6, $columns['onenumberwith0scale']->max_length);

        // We can not use assertEquals as that accepts null/false as a valid value.

        $this->assertSame('0', strval($columns['onenumberwith0scale']->scale));

        // Add one float field and check it (not official type - must work as number).

        $field = new xmldb_field('onefloat');

        $field->set_attributes(XMLDB_TYPE_FLOAT, '6,3', null, XMLDB_NOTNULL, null, 3.550);

        $dbman->add_field($table, $field);

        $this->assertTrue($dbman->field_exists($table, 'onefloat'));

        $columns = $DB->get_columns('test_table1');

        $this->assertSame('onefloat', $columns['onefloat']->name);

        $this->assertTrue($columns['onefloat']->not_null);

        // Max_length and scale cannot be checked under all DBs at all for float fields.

        $this->assertFalse($columns['onefloat']->primary_key);

        $this->assertFalse($columns['onefloat']->binary);

        $this->assertTrue($columns['onefloat']->has_default);

        $this->assertEquals(3.550, $columns['onefloat']->default_value);

        $this->assertSame('N', $columns['onefloat']->meta_type);

        // Just rounding DB information to 7 decimal digits. Fair enough to test 3.550 and avoids one nasty bug

        // in MSSQL core returning wrong floats (http://social.msdn.microsoft.com/Forums/en-US/sqldataaccess/thread/5e08de63-16bb-4f24-b645-0cf8fc669de3)

        // In any case, floats aren't officially supported by Moodle, with number/decimal type being the correct ones, so

        // this isn't a real problem at all.

        $this->assertEquals(3.550, round($DB->get_field('test_table1', 'onefloat', array(), IGNORE_MULTIPLE), 7)); // Check default has been applied.

        // Add one char field and check it.

        $field = new xmldb_field('onechar');

        $field->set_attributes(XMLDB_TYPE_CHAR, '25', null, XMLDB_NOTNULL, null, 'Nice dflt!');

        $dbman->add_field($table, $field);

        $this->assertTrue($dbman->field_exists($table, 'onechar'));

        $columns = $DB->get_columns('test_table1');

        $this->assertSame('onechar', $columns['onechar']->name);

        $this->assertEquals(25, $columns['onechar']->max_length);

        $this->assertNull($columns['onechar']->scale);

        $this->assertTrue($columns['onechar']->not_null);

        $this->assertFalse($columns['onechar']->primary_key);

        $this->assertFalse($columns['onechar']->binary);

        $this->assertTrue($columns['onechar']->has_default);

        $this->assertSame('Nice dflt!', $columns['onechar']->default_value);

        $this->assertSame('C', $columns['onechar']->meta_type);

        $this->assertEquals('Nice dflt!', $DB->get_field('test_table1', 'onechar', array(), IGNORE_MULTIPLE)); // Check default has been applied.

        // Add one big text field and check it.

        $field = new xmldb_field('onetext');

        $field->set_attributes(XMLDB_TYPE_TEXT, 'big');

        $dbman->add_field($table, $field);

        $this->assertTrue($dbman->field_exists($table, 'onetext'));

        $columns = $DB->get_columns('test_table1');

        $this->assertSame('onetext', $columns['onetext']->name);

        $this->assertEquals(-1, $columns['onetext']->max_length); // -1 means unknown or big.

        $this->assertNull($columns['onetext']->scale);

        $this->assertFalse($columns['onetext']->not_null);

        $this->assertFalse($columns['onetext']->primary_key);

        $this->assertFalse($columns['onetext']->binary);

        $this->assertFalse($columns['onetext']->has_default);

        $this->assertNull($columns['onetext']->default_value);

        $this->assertSame('X', $columns['onetext']->meta_type);

        // Add one medium text field and check it.

        $field = new xmldb_field('mediumtext');

        $field->set_attributes(XMLDB_TYPE_TEXT, 'medium');

        $dbman->add_field($table, $field);

        $columns = $DB->get_columns('test_table1');

        $this->assertTrue(($columns['mediumtext']->max_length == -1) or ($columns['mediumtext']->max_length >= 16777215)); // -1 means unknown or big.

        // Add one small text field and check it.

        $field = new xmldb_field('smalltext');

        $field->set_attributes(XMLDB_TYPE_TEXT, 'small');

        $dbman->add_field($table, $field);

        $columns = $DB->get_columns('test_table1');

        $this->assertTrue(($columns['smalltext']->max_length == -1) or ($columns['smalltext']->max_length >= 65535)); // -1 means unknown or big.

        // Add one binary field and check it.

        $field = new xmldb_field('onebinary');

        $field->set_attributes(XMLDB_TYPE_BINARY);

        $dbman->add_field($table, $field);

        $this->assertTrue($dbman->field_exists($table, 'onebinary'));

        $columns = $DB->get_columns('test_table1');

        $this->assertSame('onebinary', $columns['onebinary']->name);

        $this->assertEquals(-1, $columns['onebinary']->max_length);

        $this->assertNull($columns['onebinary']->scale);

        $this->assertFalse($columns['onebinary']->not_null);

        $this->assertFalse($columns['onebinary']->primary_key);

        $this->assertTrue($columns['onebinary']->binary);

        $this->assertFalse($columns['onebinary']->has_default);

        $this->assertNull($columns['onebinary']->default_value);

        $this->assertSame('B', $columns['onebinary']->meta_type);

        // TODO: check datetime type. Although unused should be fully supported.

    }

    /**

     * Test behaviour of drop_field()

     */

    public function test_drop_field(): void {

        $DB = $this->tdb; // Do not use global $DB!

        $dbman = $this->tdb->get_manager();

        $table = $this->create_deftable('test_table0');

        // Fill the table with some records before dropping fields.

        $this->fill_deftable('test_table0');

        // Drop field with simple xmldb_field having indexes, must return exception.

        $field = new xmldb_field('type'); // Field has indexes and default clause.

        $this->assertTrue($dbman->field_exists($table, 'type'));

        try {

            $dbman->drop_field($table, $field);

            $this->fail('Exception expected');

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('ddl_dependency_exception', $e);

        }

        $this->assertTrue($dbman->field_exists($table, 'type')); // Continues existing, drop aborted.

        // Drop field with complete xmldb_field object and related indexes, must return exception.

        $field = $table->getField('course'); // Field has indexes and default clause.

        $this->assertTrue($dbman->field_exists($table, $field));

        try {

            $dbman->drop_field($table, $field);

            $this->fail('Exception expected');

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('ddl_dependency_exception', $e);

        }

        $this->assertTrue($dbman->field_exists($table, $field)); // Continues existing, drop aborted.

        // Drop one non-existing field, must return exception.

        $field = new xmldb_field('nonexistingfield');

        $this->assertFalse($dbman->field_exists($table, $field));

        try {

            $dbman->drop_field($table, $field);

            $this->fail('Exception expected');

        } catch (\moodle_exception $e) {

            $this->assertInstanceOf('ddl_field_missing_exception', $e);

        }

        // Drop field with simple xmldb_field, not having related indexes.

        $field = new xmldb_field('forcesubscribe'); // Field has default clause.

        $this->assertTrue($dbman->field_exists($table, 'forcesubscribe'));

        $dbman->drop_field($table, $field);

        $this->assertFalse($dbman->field_exists($table, 'forcesubscribe'));

        // Drop field with complete xmldb_field object, not having related indexes.

        $field = new xmldb_field('trackingtype'); // Field has default clause.

        $this->assertTrue($dbman->field_exists($table, $field));

        $dbman->drop_field($table, $field);

        $this->assertFalse($dbman->field_exists($table, $field));

    }

    /**

     * Test behaviour of change_field_type()

     */

    public function test_change_field_type(): void {

        $DB = $this->tdb; // Do not use global $DB!

        $dbman = $this->tdb->get_manager();