Merge branch 'MDL-63333_master' of git://github.com/markn86/moodle
[moodle.git] / lib / ddl / tests / ddl_test.php
1 <?php
2 // This file is part of Moodle - http://moodle.org/
3 //
4 // Moodle is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Moodle is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
17 /**
18  * DDL layer tests.
19  *
20  * @package    core_ddl
21  * @category   phpunit
22  * @copyright  2008 Nicolas Connault
23  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
24  */
26 defined('MOODLE_INTERNAL') || die();
28 class core_ddl_testcase extends database_driver_testcase {
29     private $tables = array();
30     private $records= array();
32     protected function setUp() {
33         parent::setUp();
34         $dbman = $this->tdb->get_manager(); // Loads DDL libs.
36         $table = new xmldb_table('test_table0');
37         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
38         $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
39         $table->add_field('type', XMLDB_TYPE_CHAR, '20', null, XMLDB_NOTNULL, null, 'general');
40         $table->add_field('name', XMLDB_TYPE_CHAR, '255', null, XMLDB_NOTNULL, null);
41         $table->add_field('intro', XMLDB_TYPE_TEXT, 'small', null, XMLDB_NOTNULL, null, null);
42         $table->add_field('logo', XMLDB_TYPE_BINARY, 'big', null, null, null);
43         $table->add_field('assessed', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
44         $table->add_field('assesstimestart', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
45         $table->add_field('assesstimefinish', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
46         $table->add_field('scale', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
47         $table->add_field('maxbytes', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
48         $table->add_field('forcesubscribe', XMLDB_TYPE_INTEGER, '1', null, XMLDB_NOTNULL, null, '0');
49         $table->add_field('trackingtype', XMLDB_TYPE_INTEGER, '2', null, XMLDB_NOTNULL, null, '1');
50         $table->add_field('rsstype', XMLDB_TYPE_INTEGER, '2', null, XMLDB_NOTNULL, null, '0');
51         $table->add_field('rssarticles', XMLDB_TYPE_INTEGER, '2', null, XMLDB_NOTNULL, null, '0');
52         $table->add_field('timemodified', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
53         $table->add_field('grade', XMLDB_TYPE_NUMBER, '20,0', null, null, null, null);
54         $table->add_field('percent', XMLDB_TYPE_NUMBER, '5,2', null, null, null, 66.6);
55         $table->add_field('bignum', XMLDB_TYPE_NUMBER, '38,18', null, null, null, 1234567890.1234);
56         $table->add_field('warnafter', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
57         $table->add_field('blockafter', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
58         $table->add_field('blockperiod', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
59         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
60         $table->add_key('course', XMLDB_KEY_UNIQUE, array('course'));
61         $table->add_index('type-name', XMLDB_INDEX_UNIQUE, array('type', 'name'));
62         $table->add_index('rsstype', XMLDB_INDEX_NOTUNIQUE, array('rsstype'));
63         $table->setComment("This is a test'n drop table. You can drop it safely");
65         $this->tables[$table->getName()] = $table;
67         // Define 2 initial records for this table.
68         $this->records[$table->getName()] = array(
69             (object)array(
70                 'course' => '1',
71                 'type'   => 'general',
72                 'name'   => 'record',
73                 'intro'  => 'first record'),
74             (object)array(
75                 'course' => '2',
76                 'type'   => 'social',
77                 'name'   => 'record',
78                 'intro'  => 'second record'));
80         // Second, smaller table.
81         $table = new xmldb_table ('test_table1');
82         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
83         $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
84         $table->add_field('name', XMLDB_TYPE_CHAR, '30', null, null, null, 'Moodle');
85         $table->add_field('secondname', XMLDB_TYPE_CHAR, '30', null, XMLDB_NOTNULL, null, null);
86         $table->add_field('thirdname', XMLDB_TYPE_CHAR, '30', null, null, null, ''); // Nullable column with empty default.
87         $table->add_field('intro', XMLDB_TYPE_TEXT, 'medium', null, XMLDB_NOTNULL, null, null);
88         $table->add_field('avatar', XMLDB_TYPE_BINARY, 'medium', null, null, null, null);
89         $table->add_field('grade', XMLDB_TYPE_NUMBER, '20,10', null, null, null);
90         $table->add_field('gradefloat', XMLDB_TYPE_FLOAT, '20,0', null, null, null, null);
91         $table->add_field('percentfloat', XMLDB_TYPE_FLOAT, '5,2', null, null, null, 99.9);
92         $table->add_field('userid', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
93         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
94         $table->add_key('course', XMLDB_KEY_FOREIGN_UNIQUE, array('course'), 'test_table0', array('course'));
95         $table->setComment("This is a test'n drop table. You can drop it safely");
97         $this->tables[$table->getName()] = $table;
99         // Define 2 initial records for this table.
100         $this->records[$table->getName()] = array(
101             (object)array(
102                 'course' => '1',
103                 'secondname'   => 'first record', // Less than 10 cc, please don't modify. Some tests below depend of this.
104                 'intro'  => 'first record'),
105             (object)array(
106                 'course'       => '2',
107                 'secondname'   => 'second record', // More than 10 cc, please don't modify. Some tests below depend of this.
108                 'intro'  => 'second record'));
109     }
111     private function create_deftable($tablename) {
112         $dbman = $this->tdb->get_manager();
114         if (!isset($this->tables[$tablename])) {
115             return null;
116         }
118         $table = $this->tables[$tablename];
120         if ($dbman->table_exists($table)) {
121             $dbman->drop_table($table);
122         }
123         $dbman->create_table($table);
125         return $table;
126     }
128     /**
129      * Fill the given test table with some records, as far as
130      * DDL behaviour must be tested both with real data and
131      * with empty tables
132      * @param string $tablename
133      * @return int count of records
134      */
135     private function fill_deftable($tablename) {
136         $DB = $this->tdb; // Do not use global $DB!
137         $dbman = $this->tdb->get_manager();
139         if (!isset($this->records[$tablename])) {
140             return null;
141         }
143         if ($dbman->table_exists($tablename)) {
144             foreach ($this->records[$tablename] as $row) {
145                 $DB->insert_record($tablename, $row);
146             }
147         } else {
148             return null;
149         }
151         return count($this->records[$tablename]);
152     }
154     /**
155      * Test behaviour of table_exists()
156      */
157     public function test_table_exists() {
158         $DB = $this->tdb; // Do not use global $DB!
159         $dbman = $this->tdb->get_manager();
161         // First make sure it returns false if table does not exist.
162         $table = $this->tables['test_table0'];
164         try {
165             $result = $DB->get_records('test_table0');
166         } catch (dml_exception $e) {
167             $result = false;
168         }
169         $this->resetDebugging();
171         $this->assertFalse($result);
173         $this->assertFalse($dbman->table_exists('test_table0')); // By name..
174         $this->assertFalse($dbman->table_exists($table));        // By xmldb_table..
176         // Create table and test again.
177         $dbman->create_table($table);
179         $this->assertSame(array(), $DB->get_records('test_table0'));
180         $this->assertTrue($dbman->table_exists('test_table0')); // By name.
181         $this->assertTrue($dbman->table_exists($table));        // By xmldb_table.
183         // Drop table and test again.
184         $dbman->drop_table($table);
186         try {
187             $result = $DB->get_records('test_table0');
188         } catch (dml_exception $e) {
189             $result = false;
190         }
191         $this->resetDebugging();
193         $this->assertFalse($result);
195         $this->assertFalse($dbman->table_exists('test_table0')); // By name.
196         $this->assertFalse($dbman->table_exists($table));        // By xmldb_table.
197     }
199     /**
200      * Test behaviour of create_table()
201      */
202     public function test_create_table() {
204         $DB = $this->tdb; // Do not use global $DB!
205         $dbman = $this->tdb->get_manager();
207         // Create table.
208         $table = $this->tables['test_table1'];
210         $dbman->create_table($table);
211         $this->assertTrue($dbman->table_exists($table));
213         // Basic get_tables() test.
214         $tables = $DB->get_tables();
215         $this->assertArrayHasKey('test_table1', $tables);
217         // Basic get_columns() tests.
218         $columns = $DB->get_columns('test_table1');
219         $this->assertSame('R', $columns['id']->meta_type);
220         $this->assertSame('I', $columns['course']->meta_type);
221         $this->assertSame('C', $columns['name']->meta_type);
222         $this->assertSame('C', $columns['secondname']->meta_type);
223         $this->assertSame('C', $columns['thirdname']->meta_type);
224         $this->assertSame('X', $columns['intro']->meta_type);
225         $this->assertSame('B', $columns['avatar']->meta_type);
226         $this->assertSame('N', $columns['grade']->meta_type);
227         $this->assertSame('N', $columns['percentfloat']->meta_type);
228         $this->assertSame('I', $columns['userid']->meta_type);
229         // Some defaults.
230         $this->assertTrue($columns['course']->has_default);
231         $this->assertEquals(0, $columns['course']->default_value);
232         $this->assertTrue($columns['name']->has_default);
233         $this->assertSame('Moodle', $columns['name']->default_value);
234         $this->assertTrue($columns['secondname']->has_default);
235         $this->assertSame('', $columns['secondname']->default_value);
236         $this->assertTrue($columns['thirdname']->has_default);
237         $this->assertSame('', $columns['thirdname']->default_value);
238         $this->assertTrue($columns['percentfloat']->has_default);
239         $this->assertEquals(99.9, $columns['percentfloat']->default_value);
240         $this->assertTrue($columns['userid']->has_default);
241         $this->assertEquals(0, $columns['userid']->default_value);
243         // Basic get_indexes() test.
244         $indexes = $DB->get_indexes('test_table1');
245         $courseindex = reset($indexes);
246         $this->assertEquals(1, $courseindex['unique']);
247         $this->assertSame('course', $courseindex['columns'][0]);
249         // Check sequence returns 1 for first insert.
250         $rec = (object)array(
251             'course'     => 10,
252             'secondname' => 'not important',
253             'intro'      => 'not important');
254         $this->assertSame(1, $DB->insert_record('test_table1', $rec));
256         // Check defined defaults are working ok.
257         $dbrec = $DB->get_record('test_table1', array('id' => 1));
258         $this->assertSame('Moodle', $dbrec->name);
259         $this->assertSame('', $dbrec->thirdname);
261         // Check exceptions if multiple R columns.
262         $table = new xmldb_table ('test_table2');
263         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
264         $table->add_field('rid', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
265         $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
266         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
267         $table->add_key('primaryx', XMLDB_KEY_PRIMARY, array('id'));
268         $table->setComment("This is a test'n drop table. You can drop it safely");
270         $this->tables[$table->getName()] = $table;
272         try {
273             $dbman->create_table($table);
274             $this->fail('Exception expected');
275         } catch (moodle_exception $e) {
276             $this->assertInstanceOf('ddl_exception', $e);
277         }
279         // Check exceptions missing primary key on R column.
280         $table = new xmldb_table ('test_table2');
281         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
282         $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
283         $table->setComment("This is a test'n drop table. You can drop it safely");
285         $this->tables[$table->getName()] = $table;
287         try {
288             $dbman->create_table($table);
289             $this->fail('Exception expected');
290         } catch (moodle_exception $e) {
291             $this->assertInstanceOf('ddl_exception', $e);
292         }
294         // Long table name names - the largest allowed by the configuration which exclude the prefix to ensure it's created.
295         $tablechars = str_repeat('a', xmldb_table::NAME_MAX_LENGTH);
296         $table = new xmldb_table($tablechars);
297         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
298         $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '2');
299         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
300         $table->setComment("This is a test'n drop table. You can drop it safely");
302         $this->tables[$table->getName()] = $table;
304         $dbman->create_table($table);
305         $this->assertTrue($dbman->table_exists($table));
306         $dbman->drop_table($table);
308         // Table name is too long, ignoring any prefix size set.
309         $tablechars = str_repeat('a', xmldb_table::NAME_MAX_LENGTH + 1);
310         $table = new xmldb_table($tablechars);
311         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
312         $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '2');
313         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
314         $table->setComment("This is a test'n drop table. You can drop it safely");
316         $this->tables[$table->getName()] = $table;
318         try {
319             $dbman->create_table($table);
320             $this->fail('Exception expected');
321         } catch (moodle_exception $e) {
322             $this->assertInstanceOf('coding_exception', $e);
323         }
325         // Invalid table name.
326         $table = new xmldb_table('test_tableCD');
327         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
328         $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '2');
329         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
330         $table->setComment("This is a test'n drop table. You can drop it safely");
332         $this->tables[$table->getName()] = $table;
334         try {
335             $dbman->create_table($table);
336             $this->fail('Exception expected');
337         } catch (moodle_exception $e) {
338             $this->assertInstanceOf('coding_exception', $e);
339         }
341         // Weird column names - the largest allowed.
342         $table = new xmldb_table('test_table3');
343         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
344         $table->add_field(str_repeat('b', xmldb_field::NAME_MAX_LENGTH), XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '2');
345         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
346         $table->setComment("This is a test'n drop table. You can drop it safely");
348         $this->tables[$table->getName()] = $table;
350         $dbman->create_table($table);
351         $this->assertTrue($dbman->table_exists($table));
352         $dbman->drop_table($table);
354         // Too long field name.
355         $table = new xmldb_table('test_table4');
356         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
357         $table->add_field(str_repeat('a', xmldb_field::NAME_MAX_LENGTH + 1), XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '2');
358         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
359         $table->setComment("This is a test'n drop table. You can drop it safely");
361         $this->tables[$table->getName()] = $table;
363         try {
364             $dbman->create_table($table);
365             $this->fail('Exception expected');
366         } catch (moodle_exception $e) {
367             $this->assertInstanceOf('coding_exception', $e);
368         }
370         // Invalid field name.
371         $table = new xmldb_table('test_table4');
372         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
373         $table->add_field('abCD', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '2');
374         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
375         $table->setComment("This is a test'n drop table. You can drop it safely");
377         $this->tables[$table->getName()] = $table;
379         try {
380             $dbman->create_table($table);
381             $this->fail('Exception expected');
382         } catch (moodle_exception $e) {
383             $this->assertInstanceOf('coding_exception', $e);
384         }
386         // Invalid integer length.
387         $table = new xmldb_table('test_table4');
388         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
389         $table->add_field('course', XMLDB_TYPE_INTEGER, '21', null, XMLDB_NOTNULL, null, '2');
390         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
391         $table->setComment("This is a test'n drop table. You can drop it safely");
393         $this->tables[$table->getName()] = $table;
395         try {
396             $dbman->create_table($table);
397             $this->fail('Exception expected');
398         } catch (moodle_exception $e) {
399             $this->assertInstanceOf('coding_exception', $e);
400         }
402         // Invalid integer default.
403         $table = new xmldb_table('test_table4');
404         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
405         $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, 'x');
406         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
407         $table->setComment("This is a test'n drop table. You can drop it safely");
409         $this->tables[$table->getName()] = $table;
411         try {
412             $dbman->create_table($table);
413             $this->fail('Exception expected');
414         } catch (moodle_exception $e) {
415             $this->assertInstanceOf('coding_exception', $e);
416         }
418         // Invalid decimal length - max precision is 38 digits.
419         $table = new xmldb_table('test_table4');
420         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
421         $table->add_field('num', XMLDB_TYPE_NUMBER, '39,19', null, XMLDB_NOTNULL, null, null);
422         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
423         $table->setComment("This is a test'n drop table. You can drop it safely");
425         $this->tables[$table->getName()] = $table;
427         try {
428             $dbman->create_table($table);
429             $this->fail('Exception expected');
430         } catch (moodle_exception $e) {
431             $this->assertInstanceOf('coding_exception', $e);
432         }
434         // Invalid decimal decimals - number of decimals can't be higher than total number of digits.
435         $table = new xmldb_table('test_table4');
436         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
437         $table->add_field('num', XMLDB_TYPE_NUMBER, '10,11', null, XMLDB_NOTNULL, null, null);
438         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
439         $table->setComment("This is a test'n drop table. You can drop it safely");
441         $this->tables[$table->getName()] = $table;
443         try {
444             $dbman->create_table($table);
445             $this->fail('Exception expected');
446         } catch (moodle_exception $e) {
447             $this->assertInstanceOf('coding_exception', $e);
448         }
450         // Invalid decimal whole number - the whole number part can't have more digits than integer fields.
451         $table = new xmldb_table('test_table4');
452         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
453         $table->add_field('num', XMLDB_TYPE_NUMBER, '38,17', null, XMLDB_NOTNULL, null, null);
454         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
455         $table->setComment("This is a test'n drop table. You can drop it safely");
457         $this->tables[$table->getName()] = $table;
459         try {
460             $dbman->create_table($table);
461             $this->fail('Exception expected');
462         } catch (moodle_exception $e) {
463             $this->assertInstanceOf('coding_exception', $e);
464         }
466         // Invalid decimal decimals - negative scale not supported.
467         $table = new xmldb_table('test_table4');
468         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
469         $table->add_field('num', XMLDB_TYPE_NUMBER, '30,-5', null, XMLDB_NOTNULL, null, null);
470         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
471         $table->setComment("This is a test'n drop table. You can drop it safely");
473         $this->tables[$table->getName()] = $table;
475         try {
476             $dbman->create_table($table);
477             $this->fail('Exception expected');
478         } catch (moodle_exception $e) {
479             $this->assertInstanceOf('coding_exception', $e);
480         }
482         // Invalid decimal default.
483         $table = new xmldb_table('test_table4');
484         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
485         $table->add_field('num', XMLDB_TYPE_NUMBER, '10,5', null, XMLDB_NOTNULL, null, 'x');
486         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
487         $table->setComment("This is a test'n drop table. You can drop it safely");
489         $this->tables[$table->getName()] = $table;
491         try {
492             $dbman->create_table($table);
493             $this->fail('Exception expected');
494         } catch (moodle_exception $e) {
495             $this->assertInstanceOf('coding_exception', $e);
496         }
498         // Invalid float length.
499         $table = new xmldb_table('test_table4');
500         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
501         $table->add_field('num', XMLDB_TYPE_FLOAT, '21,10', null, XMLDB_NOTNULL, null, null);
502         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
503         $table->setComment("This is a test'n drop table. You can drop it safely");
505         $this->tables[$table->getName()] = $table;
507         try {
508             $dbman->create_table($table);
509             $this->fail('Exception expected');
510         } catch (moodle_exception $e) {
511             $this->assertInstanceOf('coding_exception', $e);
512         }
514         // Invalid float decimals.
515         $table = new xmldb_table('test_table4');
516         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
517         $table->add_field('num', XMLDB_TYPE_FLOAT, '10,11', null, XMLDB_NOTNULL, null, null);
518         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
519         $table->setComment("This is a test'n drop table. You can drop it safely");
521         $this->tables[$table->getName()] = $table;
523         try {
524             $dbman->create_table($table);
525             $this->fail('Exception expected');
526         } catch (moodle_exception $e) {
527             $this->assertInstanceOf('coding_exception', $e);
528         }
530         // Invalid float default.
531         $table = new xmldb_table('test_table4');
532         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
533         $table->add_field('num', XMLDB_TYPE_FLOAT, '10,5', null, XMLDB_NOTNULL, null, 'x');
534         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
535         $table->setComment("This is a test'n drop table. You can drop it safely");
537         $this->tables[$table->getName()] = $table;
539         try {
540             $dbman->create_table($table);
541             $this->fail('Exception expected');
542         } catch (moodle_exception $e) {
543             $this->assertInstanceOf('coding_exception', $e);
544         }
545     }
547     /**
548      * Test if database supports tables with many TEXT fields,
549      * InnoDB is known to failed during data insertion instead
550      * of table creation when text fields contain actual data.
551      */
552     public function test_row_size_limits() {
554         $DB = $this->tdb; // Do not use global $DB!
555         $dbman = $this->tdb->get_manager();
557         $text = str_repeat('š', 1333);
559         $data = new stdClass();
560         $data->name = 'test';
561         $table = new xmldb_table('test_innodb');
562         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
563         $table->add_field('name', XMLDB_TYPE_CHAR, '30', null, null, null, null);
564         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
565         for ($i = 0; $i < 20; $i++) {
566             $table->add_field('text'.$i, XMLDB_TYPE_TEXT, null, null, null, null, null);
567             $data->{'text'.$i} = $text;
568         }
569         $dbman->create_table($table);
571         try {
572             $id = $DB->insert_record('test_innodb', $data);
573             $expected = (array)$data;
574             $expected['id'] = (string)$id;
575             $this->assertEquals($expected, (array)$DB->get_record('test_innodb', array('id' => $id)), '', 0, 10, true);
576         } catch (dml_exception $e) {
577             // Give some nice error message when known problematic MySQL with InnoDB detected.
578             if ($DB->get_dbfamily() === 'mysql') {
579                 $engine = strtolower($DB->get_dbengine());
580                 if ($engine === 'innodb' or $engine === 'xtradb') {
581                     if (!$DB->is_compressed_row_format_supported()) {
582                         $this->fail("Row size limit reached in MySQL using InnoDB, configure server to use innodb_file_format=Barracuda and innodb_file_per_table=1");
583                     }
584                 }
585             }
586             throw $e;
587         }
589         $dbman->drop_table($table);
591         $data = new stdClass();
592         $data->name = 'test';
593         $table = new xmldb_table('test_innodb');
594         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
595         $table->add_field('name', XMLDB_TYPE_CHAR, '30', null, null, null, null);
596         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
597         $dbman->create_table($table);
598         $DB->insert_record('test_innodb', array('name' => 'test'));
600         for ($i = 0; $i < 20; $i++) {
601             $field = new xmldb_field('text'.$i, XMLDB_TYPE_TEXT, null, null, null, null, null);
602             $dbman->add_field($table, $field);
603             $data->{'text'.$i} = $text;
605             $id = $DB->insert_record('test_innodb', $data);
606             $expected = (array)$data;
607             $expected['id'] = (string)$id;
608             $this->assertEquals($expected, (array)$DB->get_record('test_innodb', array('id' => $id)), '', 0, 10, true);
609         }
611         $dbman->drop_table($table);
613         // MySQL VARCHAR fields may hit a different 65535 row size limit when creating tables.
614         $data = new stdClass();
615         $data->name = 'test';
616         $table = new xmldb_table('test_innodb');
617         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
618         $table->add_field('name', XMLDB_TYPE_CHAR, '30', null, null, null, null);
619         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
620         for ($i = 0; $i < 12; $i++) {
621             $table->add_field('text'.$i, XMLDB_TYPE_CHAR, '1333', null, null, null, null);
622             $data->{'text'.$i} = $text;
623         }
624         $dbman->create_table($table);
626         $id = $DB->insert_record('test_innodb', $data);
627         $expected = (array)$data;
628         $expected['id'] = (string)$id;
629         $this->assertEquals($expected, (array)$DB->get_record('test_innodb', array('id' => $id)), '', 0, 10, true);
631         $dbman->drop_table($table);
632     }
634     /**
635      * Test behaviour of drop_table()
636      */
637     public function test_drop_table() {
638         $DB = $this->tdb; // Do not use global $DB!
639         $dbman = $this->tdb->get_manager();
641         // Initially table doesn't exist.
642         $this->assertFalse($dbman->table_exists('test_table0'));
644         // Create table with contents.
645         $table = $this->create_deftable('test_table0');
646         $this->assertTrue($dbman->table_exists('test_table0'));
648         // Fill the table with some records before dropping it.
649         $this->fill_deftable('test_table0');
651         // Drop by xmldb_table object.
652         $dbman->drop_table($table);
653         $this->assertFalse($dbman->table_exists('test_table0'));
655         // Basic get_tables() test.
656         $tables = $DB->get_tables();
657         $this->assertArrayNotHasKey('test_table0', $tables);
659         // Columns cache must be empty.
660         $columns = $DB->get_columns('test_table0');
661         $this->assertEmpty($columns);
663         $indexes = $DB->get_indexes('test_table0');
664         $this->assertEmpty($indexes);
665     }
667     /**
668      * Test behaviour of rename_table()
669      */
670     public function test_rename_table() {
671         $DB = $this->tdb; // Do not use global $DB!
672         $dbman = $this->tdb->get_manager();
674         $table = $this->create_deftable('test_table1');
676         // Fill the table with some records before renaming it.
677         $insertedrows = $this->fill_deftable('test_table1');
679         $this->assertFalse($dbman->table_exists('test_table_cust1'));
680         $dbman->rename_table($table, 'test_table_cust1');
681         $this->assertTrue($dbman->table_exists('test_table_cust1'));
683         // Check sequence returns $insertedrows + 1 for this insert (after rename).
684         $rec = (object)array(
685             'course'     => 20,
686             'secondname' => 'not important',
687             'intro'      => 'not important');
688         $this->assertSame($insertedrows+1, $DB->insert_record('test_table_cust1', $rec));
690         // Verify behavior when target table already exists.
691         $sourcetable = $this->create_deftable('test_table0');
692         $targettable = $this->create_deftable('test_table1');
693         try {
694             $dbman->rename_table($sourcetable, $targettable->getName());
695             $this->fail('Exception expected');
696         } catch (moodle_exception $e) {
697             $this->assertInstanceOf('ddl_exception', $e);
698             $this->assertEquals('Table "test_table1" already exists (can not rename table)', $e->getMessage());
699         }
700     }
702     /**
703      * Test behaviour of field_exists()
704      */
705     public function test_field_exists() {
706         $dbman = $this->tdb->get_manager();
708         $table = $this->create_deftable('test_table0');
710         // String params.
711         // Give a nonexistent table as first param (throw exception).
712         try {
713             $dbman->field_exists('nonexistenttable', 'id');
714             $this->fail('Exception expected');
715         } catch (moodle_exception $e) {
716             $this->assertInstanceOf('moodle_exception', $e);
717         }
719         // Give a nonexistent field as second param (return false).
720         $this->assertFalse($dbman->field_exists('test_table0', 'nonexistentfield'));
722         // Correct string params.
723         $this->assertTrue($dbman->field_exists('test_table0', 'id'));
725         // Object params.
726         $realfield = $table->getField('id');
728         // Give a nonexistent table as first param (throw exception).
729         $nonexistenttable = new xmldb_table('nonexistenttable');
730         try {
731             $dbman->field_exists($nonexistenttable, $realfield);
732             $this->fail('Exception expected');
733         } catch (moodle_exception $e) {
734             $this->assertInstanceOf('moodle_exception', $e);
735         }
737         // Give a nonexistent field as second param (return false).
738         $nonexistentfield = new xmldb_field('nonexistentfield');
739         $this->assertFalse($dbman->field_exists($table, $nonexistentfield));
741         // Correct object params.
742         $this->assertTrue($dbman->field_exists($table, $realfield));
744         // Mix string and object params.
745         // Correct ones.
746         $this->assertTrue($dbman->field_exists($table, 'id'));
747         $this->assertTrue($dbman->field_exists('test_table0', $realfield));
748         // Non existing tables (throw exception).
749         try {
750             $this->assertFalse($dbman->field_exists($nonexistenttable, 'id'));
751             $this->fail('Exception expected');
752         } catch (moodle_exception $e) {
753             $this->assertInstanceOf('moodle_exception', $e);
754         }
755         try {
756             $this->assertFalse($dbman->field_exists('nonexistenttable', $realfield));
757             $this->fail('Exception expected');
758         } catch (moodle_exception $e) {
759             $this->assertInstanceOf('moodle_exception', $e);
760         }
761         // Non existing fields (return false).
762         $this->assertFalse($dbman->field_exists($table, 'nonexistentfield'));
763         $this->assertFalse($dbman->field_exists('test_table0', $nonexistentfield));
764     }
766     /**
767      * Test behaviour of add_field()
768      */
769     public function test_add_field() {
770         $DB = $this->tdb; // Do not use global $DB!
771         $dbman = $this->tdb->get_manager();
773         $table = $this->create_deftable('test_table1');
775         // Fill the table with some records before adding fields.
776         $this->fill_deftable('test_table1');
778         // Add one not null field without specifying default value (throws ddl_exception).
779         $field = new xmldb_field('onefield');
780         $field->set_attributes(XMLDB_TYPE_INTEGER, '6', null, XMLDB_NOTNULL, null, null);
781         try {
782             $dbman->add_field($table, $field);
783             $this->fail('Exception expected');
784         } catch (moodle_exception $e) {
785             $this->assertInstanceOf('ddl_exception', $e);
786         }
788         // Add one existing field (throws ddl_exception).
789         $field = new xmldb_field('course');
790         $field->set_attributes(XMLDB_TYPE_INTEGER, '6', null, XMLDB_NOTNULL, null, 2);
791         try {
792             $dbman->add_field($table, $field);
793             $this->fail('Exception expected');
794         } catch (moodle_exception $e) {
795             $this->assertInstanceOf('ddl_exception', $e);
796         }
798         // TODO: add one field with invalid type, must throw exception.
799         // TODO: add one text field with default, must throw exception.
800         // TODO: add one binary field with default, must throw exception.
802         // Add one integer field and check it.
803         $field = new xmldb_field('oneinteger');
804         $field->set_attributes(XMLDB_TYPE_INTEGER, '6', null, XMLDB_NOTNULL, null, 2);
805         $dbman->add_field($table, $field);
806         $this->assertTrue($dbman->field_exists($table, 'oneinteger'));
807         $columns = $DB->get_columns('test_table1');
808         $this->assertEquals('oneinteger', $columns['oneinteger']->name);
809         $this->assertTrue($columns['oneinteger']->not_null);
810         // Max_length and scale cannot be checked under all DBs at all for integer fields.
811         $this->assertFalse($columns['oneinteger']->primary_key);
812         $this->assertFalse($columns['oneinteger']->binary);
813         $this->assertTrue($columns['oneinteger']->has_default);
814         $this->assertEquals(2, $columns['oneinteger']->default_value);
815         $this->assertSame('I', $columns['oneinteger']->meta_type);
816         $this->assertEquals(2, $DB->get_field('test_table1', 'oneinteger', array(), IGNORE_MULTIPLE)); // Check default has been applied.
818         // Add one numeric field and check it.
819         $field = new xmldb_field('onenumber');
820         $field->set_attributes(XMLDB_TYPE_NUMBER, '6,3', null, XMLDB_NOTNULL, null, 2.55);
821         $dbman->add_field($table, $field);
822         $this->assertTrue($dbman->field_exists($table, 'onenumber'));
823         $columns = $DB->get_columns('test_table1');
824         $this->assertSame('onenumber', $columns['onenumber']->name);
825         $this->assertEquals(6, $columns['onenumber']->max_length);
826         $this->assertEquals(3, $columns['onenumber']->scale);
827         $this->assertTrue($columns['onenumber']->not_null);
828         $this->assertFalse($columns['onenumber']->primary_key);
829         $this->assertFalse($columns['onenumber']->binary);
830         $this->assertTrue($columns['onenumber']->has_default);
831         $this->assertEquals(2.550, $columns['onenumber']->default_value);
832         $this->assertSame('N', $columns['onenumber']->meta_type);
833         $this->assertEquals(2.550, $DB->get_field('test_table1', 'onenumber', array(), IGNORE_MULTIPLE)); // Check default has been applied.
835         // Add one numeric field with scale of 0 and check it.
836         $field = new xmldb_field('onenumberwith0scale');
837         $field->set_attributes(XMLDB_TYPE_NUMBER, '6,0', null, XMLDB_NOTNULL, null, 2);
838         $dbman->add_field($table, $field);
839         $this->assertTrue($dbman->field_exists($table, 'onenumberwith0scale'));
840         $columns = $DB->get_columns('test_table1');
841         $this->assertEquals(6, $columns['onenumberwith0scale']->max_length);
842         // We can not use assertEquals as that accepts null/false as a valid value.
843         $this->assertSame('0', strval($columns['onenumberwith0scale']->scale));
845         // Add one float field and check it (not official type - must work as number).
846         $field = new xmldb_field('onefloat');
847         $field->set_attributes(XMLDB_TYPE_FLOAT, '6,3', null, XMLDB_NOTNULL, null, 3.550);
848         $dbman->add_field($table, $field);
849         $this->assertTrue($dbman->field_exists($table, 'onefloat'));
850         $columns = $DB->get_columns('test_table1');
851         $this->assertSame('onefloat', $columns['onefloat']->name);
852         $this->assertTrue($columns['onefloat']->not_null);
853         // Max_length and scale cannot be checked under all DBs at all for float fields.
854         $this->assertFalse($columns['onefloat']->primary_key);
855         $this->assertFalse($columns['onefloat']->binary);
856         $this->assertTrue($columns['onefloat']->has_default);
857         $this->assertEquals(3.550, $columns['onefloat']->default_value);
858         $this->assertSame('N', $columns['onefloat']->meta_type);
859         // Just rounding DB information to 7 decimal digits. Fair enough to test 3.550 and avoids one nasty bug
860         // in MSSQL core returning wrong floats (http://social.msdn.microsoft.com/Forums/en-US/sqldataaccess/thread/5e08de63-16bb-4f24-b645-0cf8fc669de3)
861         // In any case, floats aren't officially supported by Moodle, with number/decimal type being the correct ones, so
862         // this isn't a real problem at all.
863         $this->assertEquals(3.550, round($DB->get_field('test_table1', 'onefloat', array(), IGNORE_MULTIPLE), 7)); // Check default has been applied.
865         // Add one char field and check it.
866         $field = new xmldb_field('onechar');
867         $field->set_attributes(XMLDB_TYPE_CHAR, '25', null, XMLDB_NOTNULL, null, 'Nice dflt!');
868         $dbman->add_field($table, $field);
869         $this->assertTrue($dbman->field_exists($table, 'onechar'));
870         $columns = $DB->get_columns('test_table1');
871         $this->assertSame('onechar', $columns['onechar']->name);
872         $this->assertEquals(25, $columns['onechar']->max_length);
873         $this->assertNull($columns['onechar']->scale);
874         $this->assertTrue($columns['onechar']->not_null);
875         $this->assertFalse($columns['onechar']->primary_key);
876         $this->assertFalse($columns['onechar']->binary);
877         $this->assertTrue($columns['onechar']->has_default);
878         $this->assertSame('Nice dflt!', $columns['onechar']->default_value);
879         $this->assertSame('C', $columns['onechar']->meta_type);
880         $this->assertEquals('Nice dflt!', $DB->get_field('test_table1', 'onechar', array(), IGNORE_MULTIPLE)); // Check default has been applied.
882         // Add one big text field and check it.
883         $field = new xmldb_field('onetext');
884         $field->set_attributes(XMLDB_TYPE_TEXT, 'big');
885         $dbman->add_field($table, $field);
886         $this->assertTrue($dbman->field_exists($table, 'onetext'));
887         $columns = $DB->get_columns('test_table1');
888         $this->assertSame('onetext', $columns['onetext']->name);
889         $this->assertEquals(-1, $columns['onetext']->max_length); // -1 means unknown or big.
890         $this->assertNull($columns['onetext']->scale);
891         $this->assertFalse($columns['onetext']->not_null);
892         $this->assertFalse($columns['onetext']->primary_key);
893         $this->assertFalse($columns['onetext']->binary);
894         $this->assertFalse($columns['onetext']->has_default);
895         $this->assertNull($columns['onetext']->default_value);
896         $this->assertSame('X', $columns['onetext']->meta_type);
898         // Add one medium text field and check it.
899         $field = new xmldb_field('mediumtext');
900         $field->set_attributes(XMLDB_TYPE_TEXT, 'medium');
901         $dbman->add_field($table, $field);
902         $columns = $DB->get_columns('test_table1');
903         $this->assertTrue(($columns['mediumtext']->max_length == -1) or ($columns['mediumtext']->max_length >= 16777215)); // -1 means unknown or big.
905         // Add one small text field and check it.
906         $field = new xmldb_field('smalltext');
907         $field->set_attributes(XMLDB_TYPE_TEXT, 'small');
908         $dbman->add_field($table, $field);
909         $columns = $DB->get_columns('test_table1');
910         $this->assertTrue(($columns['smalltext']->max_length == -1) or ($columns['smalltext']->max_length >= 65535)); // -1 means unknown or big.
912         // Add one binary field and check it.
913         $field = new xmldb_field('onebinary');
914         $field->set_attributes(XMLDB_TYPE_BINARY);
915         $dbman->add_field($table, $field);
916         $this->assertTrue($dbman->field_exists($table, 'onebinary'));
917         $columns = $DB->get_columns('test_table1');
918         $this->assertSame('onebinary', $columns['onebinary']->name);
919         $this->assertEquals(-1, $columns['onebinary']->max_length);
920         $this->assertNull($columns['onebinary']->scale);
921         $this->assertFalse($columns['onebinary']->not_null);
922         $this->assertFalse($columns['onebinary']->primary_key);
923         $this->assertTrue($columns['onebinary']->binary);
924         $this->assertFalse($columns['onebinary']->has_default);
925         $this->assertNull($columns['onebinary']->default_value);
926         $this->assertSame('B', $columns['onebinary']->meta_type);
928         // TODO: check datetime type. Although unused should be fully supported.
929     }
931     /**
932      * Test behaviour of drop_field()
933      */
934     public function test_drop_field() {
935         $DB = $this->tdb; // Do not use global $DB!
936         $dbman = $this->tdb->get_manager();
938         $table = $this->create_deftable('test_table0');
940         // Fill the table with some records before dropping fields.
941         $this->fill_deftable('test_table0');
943         // Drop field with simple xmldb_field having indexes, must return exception.
944         $field = new xmldb_field('type'); // Field has indexes and default clause.
945         $this->assertTrue($dbman->field_exists($table, 'type'));
946         try {
947             $dbman->drop_field($table, $field);
948             $this->fail('Exception expected');
949         } catch (moodle_exception $e) {
950             $this->assertInstanceOf('ddl_dependency_exception', $e);
951         }
952         $this->assertTrue($dbman->field_exists($table, 'type')); // Continues existing, drop aborted.
954         // Drop field with complete xmldb_field object and related indexes, must return exception.
955         $field = $table->getField('course'); // Field has indexes and default clause.
956         $this->assertTrue($dbman->field_exists($table, $field));
957         try {
958             $dbman->drop_field($table, $field);
959             $this->fail('Exception expected');
960         } catch (moodle_exception $e) {
961             $this->assertInstanceOf('ddl_dependency_exception', $e);
962         }
963         $this->assertTrue($dbman->field_exists($table, $field)); // Continues existing, drop aborted.
965         // Drop one non-existing field, must return exception.
966         $field = new xmldb_field('nonexistingfield');
967         $this->assertFalse($dbman->field_exists($table, $field));
968         try {
969             $dbman->drop_field($table, $field);
970             $this->fail('Exception expected');
971         } catch (moodle_exception $e) {
972             $this->assertInstanceOf('ddl_field_missing_exception', $e);
973         }
975         // Drop field with simple xmldb_field, not having related indexes.
976         $field = new xmldb_field('forcesubscribe'); // Field has default clause.
977         $this->assertTrue($dbman->field_exists($table, 'forcesubscribe'));
978         $dbman->drop_field($table, $field);
979         $this->assertFalse($dbman->field_exists($table, 'forcesubscribe'));
981         // Drop field with complete xmldb_field object, not having related indexes.
982         $field = new xmldb_field('trackingtype'); // Field has default clause.
983         $this->assertTrue($dbman->field_exists($table, $field));
984         $dbman->drop_field($table, $field);
985         $this->assertFalse($dbman->field_exists($table, $field));
986     }
988     /**
989      * Test behaviour of change_field_type()
990      */
991     public function test_change_field_type() {
992         $DB = $this->tdb; // Do not use global $DB!
993         $dbman = $this->tdb->get_manager();
995         // Create table with indexed field and not indexed field to
996         // perform tests in both fields, both having defaults.
997         $table = new xmldb_table('test_table_cust0');
998         $table->add_field('id', XMLDB_TYPE_INTEGER, '2', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
999         $table->add_field('onenumber', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '2');
1000         $table->add_field('anothernumber', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '4');
1001         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
1002         $table->add_index('onenumber', XMLDB_INDEX_NOTUNIQUE, array('onenumber'));
1003         $dbman->create_table($table);
1005         $record = new stdClass();
1006         $record->onenumber = 2;
1007         $record->anothernumber = 4;
1008         $recoriginal = $DB->insert_record('test_table_cust0', $record);
1010         // Change column from integer to varchar. Must return exception because of dependent index.
1011         $field = new xmldb_field('onenumber');
1012         $field->set_attributes(XMLDB_TYPE_CHAR, '30', null, XMLDB_NOTNULL, null, 'test');
1013         try {
1014             $dbman->change_field_type($table, $field);
1015             $this->fail('Exception expected');
1016         } catch (moodle_exception $e) {
1017             $this->assertInstanceOf('ddl_dependency_exception', $e);
1018         }
1019         // Column continues being integer 10 not null default 2.
1020         $columns = $DB->get_columns('test_table_cust0');
1021         $this->assertSame('I', $columns['onenumber']->meta_type);
1022         // TODO: check the rest of attributes.
1024         // Change column from integer to varchar. Must work because column has no dependencies.
1025         $field = new xmldb_field('anothernumber');
1026         $field->set_attributes(XMLDB_TYPE_CHAR, '30', null, XMLDB_NOTNULL, null, 'test');
1027         $dbman->change_field_type($table, $field);
1028         // Column is char 30 not null default 'test' now.
1029         $columns = $DB->get_columns('test_table_cust0');
1030         $this->assertSame('C', $columns['anothernumber']->meta_type);
1031         // TODO: check the rest of attributes.
1033         // Change column back from char to integer.
1034         $field = new xmldb_field('anothernumber');
1035         $field->set_attributes(XMLDB_TYPE_INTEGER, '8', null, XMLDB_NOTNULL, null, '5');
1036         $dbman->change_field_type($table, $field);
1037         // Column is integer 8 not null default 5 now.
1038         $columns = $DB->get_columns('test_table_cust0');
1039         $this->assertSame('I', $columns['anothernumber']->meta_type);
1040         // TODO: check the rest of attributes.
1042         // Change column once more from integer to char.
1043         $field = new xmldb_field('anothernumber');
1044         $field->set_attributes(XMLDB_TYPE_CHAR, '20', null, XMLDB_NOTNULL, null, "test'n drop");
1045         $dbman->change_field_type($table, $field);
1046         // Column is char 30 not null default "test'n drop" now.
1047         $columns = $DB->get_columns('test_table_cust0');
1048         $this->assertSame('C', $columns['anothernumber']->meta_type);
1049         // TODO: check the rest of attributes.
1051         // Insert one string value and try to convert to integer. Must throw exception.
1052         $record = new stdClass();
1053         $record->onenumber = 7;
1054         $record->anothernumber = 'string value';
1055         $rectodrop = $DB->insert_record('test_table_cust0', $record);
1056         $field = new xmldb_field('anothernumber');
1057         $field->set_attributes(XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '5');
1058         try {
1059             $dbman->change_field_type($table, $field);
1060             $this->fail('Exception expected');
1061         } catch (moodle_exception $e) {
1062             $this->assertInstanceOf('ddl_change_structure_exception', $e);
1063         }
1064         // Column continues being char 30 not null default "test'n drop" now.
1065         $this->assertSame('C', $columns['anothernumber']->meta_type);
1066         // TODO: check the rest of attributes.
1067         $DB->delete_records('test_table_cust0', array('id' => $rectodrop)); // Delete the string record.
1069         // Change the column from varchar to float.
1070         $field = new xmldb_field('anothernumber');
1071         $field->set_attributes(XMLDB_TYPE_FLOAT, '20,10', null, null, null, null);
1072         $dbman->change_field_type($table, $field);
1073         // Column is float 20,10 null default null.
1074         $columns = $DB->get_columns('test_table_cust0');
1075         $this->assertSame('N', $columns['anothernumber']->meta_type); // Floats are seen as number.
1076         // TODO: check the rest of attributes.
1078         // Change the column back from float to varchar.
1079         $field = new xmldb_field('anothernumber');
1080         $field->set_attributes(XMLDB_TYPE_CHAR, '20', null, XMLDB_NOTNULL, null, 'test');
1081         $dbman->change_field_type($table, $field);
1082         // Column is char 20 not null default "test" now.
1083         $columns = $DB->get_columns('test_table_cust0');
1084         $this->assertSame('C', $columns['anothernumber']->meta_type);
1085         // TODO: check the rest of attributes.
1087         // Change the column from varchar to number.
1088         $field = new xmldb_field('anothernumber');
1089         $field->set_attributes(XMLDB_TYPE_NUMBER, '20,10', null, null, null, null);
1090         $dbman->change_field_type($table, $field);
1091         // Column is number 20,10 null default null now.
1092         $columns = $DB->get_columns('test_table_cust0');
1093         $this->assertSame('N', $columns['anothernumber']->meta_type);
1094         // TODO: check the rest of attributes.
1096         // Change the column from number to integer.
1097         $field = new xmldb_field('anothernumber');
1098         $field->set_attributes(XMLDB_TYPE_INTEGER, '2', null, null, null, null);
1099         $dbman->change_field_type($table, $field);
1100         // Column is integer 2 null default null now.
1101         $columns = $DB->get_columns('test_table_cust0');
1102         $this->assertSame('I', $columns['anothernumber']->meta_type);
1103         // TODO: check the rest of attributes.
1105         // Change the column from integer to text.
1106         $field = new xmldb_field('anothernumber');
1107         $field->set_attributes(XMLDB_TYPE_TEXT, 'big', null, XMLDB_NOTNULL, null, null);
1108         $dbman->change_field_type($table, $field);
1109         // Column is char text not null default null.
1110         $columns = $DB->get_columns('test_table_cust0');
1111         $this->assertSame('X', $columns['anothernumber']->meta_type);
1113         // Change the column back from text to number.
1114         $field = new xmldb_field('anothernumber');
1115         $field->set_attributes(XMLDB_TYPE_NUMBER, '20,10', null, null, null, null);
1116         $dbman->change_field_type($table, $field);
1117         // Column is number 20,10 null default null now.
1118         $columns = $DB->get_columns('test_table_cust0');
1119         $this->assertSame('N', $columns['anothernumber']->meta_type);
1120         // TODO: check the rest of attributes.
1122         // Change the column from number to text.
1123         $field = new xmldb_field('anothernumber');
1124         $field->set_attributes(XMLDB_TYPE_TEXT, 'big', null, XMLDB_NOTNULL, null, null);
1125         $dbman->change_field_type($table, $field);
1126         // Column is char text not null default "test" now.
1127         $columns = $DB->get_columns('test_table_cust0');
1128         $this->assertSame('X', $columns['anothernumber']->meta_type);
1129         // TODO: check the rest of attributes.
1131         // Change the column back from text to integer.
1132         $field = new xmldb_field('anothernumber');
1133         $field->set_attributes(XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, 10);
1134         $dbman->change_field_type($table, $field);
1135         // Column is integer 10 not null default 10.
1136         $columns = $DB->get_columns('test_table_cust0');
1137         $this->assertSame('I', $columns['anothernumber']->meta_type);
1138         // TODO: check the rest of attributes.
1140         // Check original value has survived to all the type changes.
1141         $this->assertnotEmpty($rec = $DB->get_record('test_table_cust0', array('id' => $recoriginal)));
1142         $this->assertEquals(4, $rec->anothernumber);
1144         $dbman->drop_table($table);
1145         $this->assertFalse($dbman->table_exists($table));
1146     }
1148     /**
1149      * Test behaviour of test_change_field_precision()
1150      */
1151     public function test_change_field_precision() {
1152         $DB = $this->tdb; // Do not use global $DB!
1153         $dbman = $this->tdb->get_manager();
1155         $table = $this->create_deftable('test_table1');
1157         // Fill the table with some records before dropping fields.
1158         $this->fill_deftable('test_table1');
1160         // Change text field from medium to big.
1161         $field = new xmldb_field('intro');
1162         $field->set_attributes(XMLDB_TYPE_TEXT, 'big', null, XMLDB_NOTNULL, null, null);
1163         $dbman->change_field_precision($table, $field);
1164         $columns = $DB->get_columns('test_table1');
1165         // Cannot check the text type, only the metatype.
1166         $this->assertSame('X', $columns['intro']->meta_type);
1167         // TODO: check the rest of attributes.
1169         // Change char field from 30 to 20.
1170         $field = new xmldb_field('secondname');
1171         $field->set_attributes(XMLDB_TYPE_CHAR, '20', null, XMLDB_NOTNULL, null, null);
1172         $dbman->change_field_precision($table, $field);
1173         $columns = $DB->get_columns('test_table1');
1174         $this->assertSame('C', $columns['secondname']->meta_type);
1175         // TODO: check the rest of attributes.
1177         // Change char field from 20 to 10, having contents > 10cc. Throw exception.
1178         $field = new xmldb_field('secondname');
1179         $field->set_attributes(XMLDB_TYPE_CHAR, '10', null, XMLDB_NOTNULL, null, null);
1180         try {
1181             $dbman->change_field_precision($table, $field);
1182             $this->fail('Exception expected');
1183         } catch (moodle_exception $e) {
1184             $this->assertInstanceOf('ddl_change_structure_exception', $e);
1185         }
1186         // No changes in field specs at all.
1187         $columns = $DB->get_columns('test_table1');
1188         $this->assertSame('C', $columns['secondname']->meta_type);
1189         // TODO: check the rest of attributes.
1191         // Change number field from 20,10 to 10,2.
1192         $field = new xmldb_field('grade');
1193         $field->set_attributes(XMLDB_TYPE_NUMBER, '10,2', null, null, null, null);
1194         $dbman->change_field_precision($table, $field);
1195         $columns = $DB->get_columns('test_table1');
1196         $this->assertSame('N', $columns['grade']->meta_type);
1197         // TODO: check the rest of attributes.
1199         // Change integer field from 10 to 2.
1200         $field = new xmldb_field('userid');
1201         $field->set_attributes(XMLDB_TYPE_INTEGER, '2', null, XMLDB_NOTNULL, null, '0');
1202         $dbman->change_field_precision($table, $field);
1203         $columns = $DB->get_columns('test_table1');
1204         $this->assertSame('I', $columns['userid']->meta_type);
1205         // TODO: check the rest of attributes.
1207         // Change the column from integer (2) to integer (6) (forces change of type in some DBs).
1208         $field = new xmldb_field('userid');
1209         $field->set_attributes(XMLDB_TYPE_INTEGER, '6', null, null, null, null);
1210         $dbman->change_field_precision($table, $field);
1211         // Column is integer 6 null default null now.
1212         $columns = $DB->get_columns('test_table1');
1213         $this->assertSame('I', $columns['userid']->meta_type);
1214         // TODO: check the rest of attributes.
1216         // Insert one record with 6-digit field.
1217         $record = new stdClass();
1218         $record->course = 10;
1219         $record->secondname  = 'third record';
1220         $record->intro  = 'third record';
1221         $record->userid = 123456;
1222         $DB->insert_record('test_table1', $record);
1223         // Change integer field from 6 to 2, contents are bigger, must throw exception.
1224         $field = new xmldb_field('userid');
1225         $field->set_attributes(XMLDB_TYPE_INTEGER, '2', null, XMLDB_NOTNULL, null, '0');
1226         try {
1227             $dbman->change_field_precision($table, $field);
1228             $this->fail('Exception expected');
1229         } catch (moodle_exception $e) {
1230             $this->assertInstanceOf('ddl_change_structure_exception', $e);
1231         }
1232         // No changes in field specs at all.
1233         $columns = $DB->get_columns('test_table1');
1234         $this->assertSame('I', $columns['userid']->meta_type);
1235         // TODO: check the rest of attributes.
1237         // Change integer field from 10 to 3, in field used by index. must throw exception.
1238         $field = new xmldb_field('course');
1239         $field->set_attributes(XMLDB_TYPE_INTEGER, '3', null, XMLDB_NOTNULL, null, '0');
1240         try {
1241             $dbman->change_field_precision($table, $field);
1242             $this->fail('Exception expected');
1243         } catch (moodle_exception $e) {
1244             $this->assertInstanceOf('ddl_dependency_exception', $e);
1245         }
1246         // No changes in field specs at all.
1247         $columns = $DB->get_columns('test_table1');
1248         $this->assertSame('I', $columns['course']->meta_type);
1249         // TODO: check the rest of attributes.
1250     }
1252     public function testChangeFieldNullability() {
1253         $DB = $this->tdb; // Do not use global $DB!
1254         $dbman = $this->tdb->get_manager();
1256         $table = new xmldb_table('test_table_cust0');
1257         $table->add_field('id', XMLDB_TYPE_INTEGER, '2', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
1258         $table->add_field('name', XMLDB_TYPE_CHAR, '30', null, XMLDB_NOTNULL, null, null);
1259         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
1260         $dbman->create_table($table);
1262         $record = new stdClass();
1263         $record->name = null;
1265         try {
1266             $result = $DB->insert_record('test_table_cust0', $record, false);
1267         } catch (dml_exception $e) {
1268             $result = false;
1269         }
1270         $this->resetDebugging();
1271         $this->assertFalse($result);
1273         $field = new xmldb_field('name');
1274         $field->set_attributes(XMLDB_TYPE_CHAR, '30', null, null, null, null);
1275         $dbman->change_field_notnull($table, $field);
1277         $this->assertTrue($DB->insert_record('test_table_cust0', $record, false));
1279         // TODO: add some tests with existing data in table.
1280         $DB->delete_records('test_table_cust0');
1282         $field = new xmldb_field('name');
1283         $field->set_attributes(XMLDB_TYPE_CHAR, '30', null, XMLDB_NOTNULL, null, null);
1284         $dbman->change_field_notnull($table, $field);
1286         try {
1287             $result = $DB->insert_record('test_table_cust0', $record, false);
1288         } catch (dml_exception $e) {
1289             $result = false;
1290         }
1291         $this->resetDebugging();
1292         $this->assertFalse($result);
1294         $dbman->drop_table($table);
1295     }
1297     public function testChangeFieldDefault() {
1298         $DB = $this->tdb; // Do not use global $DB!
1299         $dbman = $this->tdb->get_manager();
1301         $table = new xmldb_table('test_table_cust0');
1302         $table->add_field('id', XMLDB_TYPE_INTEGER, '2', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
1303         $table->add_field('onenumber', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
1304         $table->add_field('name', XMLDB_TYPE_CHAR, '30', null, XMLDB_NOTNULL, null, 'Moodle');
1305         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
1306         $dbman->create_table($table);
1308         $field = new xmldb_field('name');
1309         $field->set_attributes(XMLDB_TYPE_CHAR, '30', null, XMLDB_NOTNULL, null, 'Moodle2');
1310         $dbman->change_field_default($table, $field);
1312         $record = new stdClass();
1313         $record->onenumber = 666;
1314         $id = $DB->insert_record('test_table_cust0', $record);
1316         $record = $DB->get_record('test_table_cust0', array('id'=>$id));
1317         $this->assertSame('Moodle2', $record->name);
1319         $field = new xmldb_field('onenumber');
1320         $field->set_attributes(XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, 666);
1321         $dbman->change_field_default($table, $field);
1323         $record = new stdClass();
1324         $record->name = 'something';
1325         $id = $DB->insert_record('test_table_cust0', $record);
1327         $record = $DB->get_record('test_table_cust0', array('id'=>$id));
1328         $this->assertSame('666', $record->onenumber);
1330         $dbman->drop_table($table);
1331     }
1333     public function testAddUniqueIndex() {
1334         $DB = $this->tdb; // Do not use global $DB!
1335         $dbman = $this->tdb->get_manager();
1337         $table = new xmldb_table('test_table_cust0');
1338         $table->add_field('id', XMLDB_TYPE_INTEGER, '2', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
1339         $table->add_field('onenumber', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
1340         $table->add_field('name', XMLDB_TYPE_CHAR, '30', null, XMLDB_NOTNULL, null, 'Moodle');
1341         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
1342         $dbman->create_table($table);
1344         $record = new stdClass();
1345         $record->onenumber = 666;
1346         $record->name = 'something';
1347         $DB->insert_record('test_table_cust0', $record, false);
1349         $index = new xmldb_index('onenumber-name');
1350         $index->set_attributes(XMLDB_INDEX_UNIQUE, array('onenumber', 'name'));
1351         $dbman->add_index($table, $index);
1353         try {
1354             $result = $DB->insert_record('test_table_cust0', $record, false);
1355         } catch (dml_exception $e) {
1356             $result = false;
1357         }
1358         $this->resetDebugging();
1359         $this->assertFalse($result);
1361         $dbman->drop_table($table);
1362     }
1364     public function testAddNonUniqueIndex() {
1365         $dbman = $this->tdb->get_manager();
1367         $table = $this->create_deftable('test_table1');
1368         $index = new xmldb_index('secondname');
1369         $index->set_attributes(XMLDB_INDEX_NOTUNIQUE, array('course', 'name'));
1370         $dbman->add_index($table, $index);
1371         $this->assertTrue($dbman->index_exists($table, $index));
1373         try {
1374             $dbman->add_index($table, $index);
1375             $this->fail('Exception expected for duplicate indexes');
1376         } catch (moodle_exception $e) {
1377             $this->assertInstanceOf('ddl_exception', $e);
1378         }
1380         $index = new xmldb_index('third');
1381         $index->set_attributes(XMLDB_INDEX_NOTUNIQUE, array('course'));
1382         try {
1383             $dbman->add_index($table, $index);
1384             $this->fail('Exception expected for duplicate indexes');
1385         } catch (moodle_exception $e) {
1386             $this->assertInstanceOf('ddl_exception', $e);
1387         }
1389         $table = new xmldb_table('test_table_cust0');
1390         $table->add_field('id', XMLDB_TYPE_INTEGER, '2', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
1391         $table->add_field('onenumber', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
1392         $table->add_field('name', XMLDB_TYPE_CHAR, '30', null, XMLDB_NOTNULL, null, 'Moodle');
1393         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
1394         $table->add_key('onenumber', XMLDB_KEY_FOREIGN, array('onenumber'));
1396         try {
1397             $table->add_index('onenumber', XMLDB_INDEX_NOTUNIQUE, array('onenumber'));
1398             $this->fail('Coding exception expected');
1399         } catch (moodle_exception $e) {
1400             $this->assertInstanceOf('coding_exception', $e);
1401         }
1403         $table = new xmldb_table('test_table_cust0');
1404         $table->add_field('id', XMLDB_TYPE_INTEGER, '2', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
1405         $table->add_field('onenumber', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
1406         $table->add_field('name', XMLDB_TYPE_CHAR, '30', null, XMLDB_NOTNULL, null, 'Moodle');
1407         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
1408         $table->add_index('onenumber', XMLDB_INDEX_NOTUNIQUE, array('onenumber'));
1410         try {
1411             $table->add_key('onenumber', XMLDB_KEY_FOREIGN, array('onenumber'));
1412             $this->fail('Coding exception expected');
1413         } catch (moodle_exception $e) {
1414             $this->assertInstanceOf('coding_exception', $e);
1415         }
1417     }
1419     public function testFindIndexName() {
1420         $dbman = $this->tdb->get_manager();
1422         $table = $this->create_deftable('test_table1');
1423         $index = new xmldb_index('secondname');
1424         $index->set_attributes(XMLDB_INDEX_NOTUNIQUE, array('course', 'name'));
1425         $dbman->add_index($table, $index);
1427         // DBM Systems name their indices differently - do not test the actual index name.
1428         $result = $dbman->find_index_name($table, $index);
1429         $this->assertTrue(!empty($result));
1431         $nonexistentindex = new xmldb_index('nonexistentindex');
1432         $nonexistentindex->set_attributes(XMLDB_INDEX_NOTUNIQUE, array('name'));
1433         $this->assertFalse($dbman->find_index_name($table, $nonexistentindex));
1434     }
1436     public function testDropIndex() {
1437         $DB = $this->tdb; // Do not use global $DB!
1439         $dbman = $this->tdb->get_manager();
1441         $table = $this->create_deftable('test_table1');
1442         $index = new xmldb_index('secondname');
1443         $index->set_attributes(XMLDB_INDEX_NOTUNIQUE, array('course', 'name'));
1444         $dbman->add_index($table, $index);
1446         $dbman->drop_index($table, $index);
1447         $this->assertFalse($dbman->find_index_name($table, $index));
1449         // Test we are able to drop indexes having hyphens MDL-22804.
1450         // Create index with hyphens (by hand).
1451         $indexname = 'test-index-with-hyphens';
1452         switch ($DB->get_dbfamily()) {
1453             case 'mysql':
1454                 $indexname = '`' . $indexname . '`';
1455                 break;
1456             default:
1457                 $indexname = '"' . $indexname . '"';
1458         }
1459         $stmt = "CREATE INDEX {$indexname} ON {$DB->get_prefix()}test_table1 (course, name)";
1460         $DB->change_database_structure($stmt);
1461         $this->assertNotEmpty($dbman->find_index_name($table, $index));
1462         // Index created, let's drop it using db manager stuff.
1463         $index = new xmldb_index('indexname', XMLDB_INDEX_NOTUNIQUE, array('course', 'name'));
1464         $dbman->drop_index($table, $index);
1465         $this->assertFalse($dbman->find_index_name($table, $index));
1466     }
1468     public function testAddUniqueKey() {
1469         $dbman = $this->tdb->get_manager();
1471         $table = $this->create_deftable('test_table1');
1472         $key = new xmldb_key('id-course-grade');
1473         $key->set_attributes(XMLDB_KEY_UNIQUE, array('id', 'course', 'grade'));
1474         $dbman->add_key($table, $key);
1476         // No easy way to test it, this just makes sure no errors are encountered.
1477         $this->assertTrue(true);
1478     }
1480     public function testAddForeignUniqueKey() {
1481         $dbman = $this->tdb->get_manager();
1483         $table = $this->create_deftable('test_table1');
1484         $this->create_deftable('test_table0');
1486         $key = new xmldb_key('course');
1487         $key->set_attributes(XMLDB_KEY_FOREIGN_UNIQUE, array('course'), 'test_table0', array('id'));
1488         $dbman->add_key($table, $key);
1490         // No easy way to test it, this just makes sure no errors are encountered.
1491         $this->assertTrue(true);
1492     }
1494     public function testDropKey() {
1495         $dbman = $this->tdb->get_manager();
1497         $table = $this->create_deftable('test_table1');
1498         $this->create_deftable('test_table0');
1500         $key = new xmldb_key('course');
1501         $key->set_attributes(XMLDB_KEY_FOREIGN_UNIQUE, array('course'), 'test_table0', array('id'));
1502         $dbman->add_key($table, $key);
1504         $dbman->drop_key($table, $key);
1506         // No easy way to test it, this just makes sure no errors are encountered.
1507         $this->assertTrue(true);
1508     }
1510     public function testAddForeignKey() {
1511         $dbman = $this->tdb->get_manager();
1513         $table = $this->create_deftable('test_table1');
1514         $this->create_deftable('test_table0');
1516         $key = new xmldb_key('course');
1517         $key->set_attributes(XMLDB_KEY_FOREIGN, array('course'), 'test_table0', array('id'));
1518         $dbman->add_key($table, $key);
1520         // No easy way to test it, this just makes sure no errors are encountered.
1521         $this->assertTrue(true);
1522     }
1524     public function testDropForeignKey() {
1525         $dbman = $this->tdb->get_manager();
1527         $table = $this->create_deftable('test_table1');
1528         $this->create_deftable('test_table0');
1530         $key = new xmldb_key('course');
1531         $key->set_attributes(XMLDB_KEY_FOREIGN, array('course'), 'test_table0', array('id'));
1532         $dbman->add_key($table, $key);
1534         $dbman->drop_key($table, $key);
1536         // No easy way to test it, this just makes sure no errors are encountered.
1537         $this->assertTrue(true);
1538     }
1540     public function testRenameField() {
1541         $DB = $this->tdb; // Do not use global $DB!
1542         $dbman = $this->tdb->get_manager();
1544         $table = $this->create_deftable('test_table0');
1545         $field = new xmldb_field('type');
1546         $field->set_attributes(XMLDB_TYPE_CHAR, '20', null, XMLDB_NOTNULL, null, 'general', 'course');
1548         // 1. Rename the 'type' field into a generic new valid name.
1549         // This represents the standard use case.
1550         $dbman->rename_field($table, $field, 'newfieldname');
1552         $columns = $DB->get_columns('test_table0');
1554         $this->assertArrayNotHasKey('type', $columns);
1555         $this->assertArrayHasKey('newfieldname', $columns);
1556         $field->setName('newfieldname');
1558         // 2. Rename the 'newfieldname' field into a reserved word, for testing purposes.
1559         // This represents a questionable use case: we should support it but discourage the use of it on peer reviewing.
1560         $dbman->rename_field($table, $field, 'where');
1562         $columns = $DB->get_columns('test_table0');
1564         $this->assertArrayNotHasKey('newfieldname', $columns);
1565         $this->assertArrayHasKey('where', $columns);
1567         // 3. Create a table with a column name named w/ a reserved word and get rid of it.
1568         // This represents a "recovering" use case: a field name could be a reserved word in the future, at least for a DB type.
1569         $table = new xmldb_table('test_table_res_word');
1570         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
1571         $table->add_field('where', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
1572         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
1573         $table->setComment("This is a test'n drop table. You can drop it safely");
1574         $dbman->create_table($table);
1575         $dbman->table_exists('test_table_res_word');
1577         $columns = $DB->get_columns('test_table_res_word');
1578         $this->assertArrayHasKey('where', $columns);
1579         $field = $table->getField('where');
1581         $dbman->rename_field($table, $field, 'newfieldname');
1583         $columns = $DB->get_columns('test_table_res_word');
1585         $this->assertArrayNotHasKey('where', $columns);
1586         $this->assertArrayHasKey('newfieldname', $columns);
1587     }
1589     public function testIndexExists() {
1590         // Skipping: this is just a test of find_index_name.
1591     }
1593     public function testFindKeyName() {
1594         $dbman = $this->tdb->get_manager();
1596         $table = $this->create_deftable('test_table0');
1597         $key = $table->getKey('primary');
1599         // With Mysql, the return value is actually "mdl_test_id_pk".
1600         $result = $dbman->find_key_name($table, $key);
1601         $this->assertTrue(!empty($result));
1602     }
1604     public function testDeleteTablesFromXmldbFile() {
1605         $dbman = $this->tdb->get_manager();
1607         $this->create_deftable('test_table1');
1609         $this->assertTrue($dbman->table_exists('test_table1'));
1611         // Feed nonexistent file.
1612         try {
1613             $dbman->delete_tables_from_xmldb_file('fpsoiudfposui');
1614             $this->fail('Exception expected');
1615         } catch (moodle_exception $e) {
1616             $this->resetDebugging();
1617             $this->assertInstanceOf('moodle_exception', $e);
1618         }
1620         try {
1621             $dbman->delete_tables_from_xmldb_file(__DIR__ . '/fixtures/invalid.xml');
1622             $this->fail('Exception expected');
1623         } catch (moodle_exception $e) {
1624             $this->resetDebugging();
1625             $this->assertInstanceOf('moodle_exception', $e);
1626         }
1628         // Check that the table has not been deleted from DB.
1629         $this->assertTrue($dbman->table_exists('test_table1'));
1631         // Real and valid xml file.
1632         // TODO: drop UNSINGED completely in Moodle 2.4.
1633         $dbman->delete_tables_from_xmldb_file(__DIR__ . '/fixtures/xmldb_table.xml');
1635         // Check that the table has been deleted from DB.
1636         $this->assertFalse($dbman->table_exists('test_table1'));
1637     }
1639     public function testInstallFromXmldbFile() {
1640         $dbman = $this->tdb->get_manager();
1642         // Feed nonexistent file.
1643         try {
1644             $dbman->install_from_xmldb_file('fpsoiudfposui');
1645             $this->fail('Exception expected');
1646         } catch (moodle_exception $e) {
1647             $this->resetDebugging();
1648             $this->assertInstanceOf('moodle_exception', $e);
1649         }
1651         try {
1652             $dbman->install_from_xmldb_file(__DIR__ . '/fixtures/invalid.xml');
1653             $this->fail('Exception expected');
1654         } catch (moodle_exception $e) {
1655             $this->resetDebugging();
1656             $this->assertInstanceOf('moodle_exception', $e);
1657         }
1659         // Check that the table has not yet been created in DB.
1660         $this->assertFalse($dbman->table_exists('test_table1'));
1662         // Real and valid xml file.
1663         $dbman->install_from_xmldb_file(__DIR__ . '/fixtures/xmldb_table.xml');
1664         $this->assertTrue($dbman->table_exists('test_table1'));
1665     }
1667     public function test_temp_tables() {
1668         $DB = $this->tdb; // Do not use global $DB!
1669         $dbman = $this->tdb->get_manager();
1671         // Create temp table0.
1672         $table0 = $this->tables['test_table0'];
1673         $dbman->create_temp_table($table0);
1674         $this->assertTrue($dbman->table_exists('test_table0'));
1676         // Try to create temp table with same name, must throw exception.
1677         $dupetable = $this->tables['test_table0'];
1678         try {
1679             $dbman->create_temp_table($dupetable);
1680             $this->fail('Exception expected');
1681         } catch (moodle_exception $e) {
1682             $this->assertInstanceOf('ddl_exception', $e);
1683         }
1685         // Try to create table with same name, must throw exception.
1686         $dupetable = $this->tables['test_table0'];
1687         try {
1688             $dbman->create_table($dupetable);
1689             $this->fail('Exception expected');
1690         } catch (moodle_exception $e) {
1691             $this->assertInstanceOf('ddl_exception', $e);
1692         }
1694         // Create another temp table1.
1695         $table1 = $this->tables['test_table1'];
1696         $dbman->create_temp_table($table1);
1697         $this->assertTrue($dbman->table_exists('test_table1'));
1699         // Get columns and perform some basic tests.
1700         $columns = $DB->get_columns('test_table1');
1701         $this->assertCount(11, $columns);
1702         $this->assertTrue($columns['name'] instanceof database_column_info);
1703         $this->assertEquals(30, $columns['name']->max_length);
1704         $this->assertTrue($columns['name']->has_default);
1705         $this->assertEquals('Moodle', $columns['name']->default_value);
1707         // Insert some records.
1708         $inserted = $this->fill_deftable('test_table1');
1709         $records = $DB->get_records('test_table1');
1710         $this->assertCount($inserted, $records);
1711         $this->assertSame($records[1]->course, $this->records['test_table1'][0]->course);
1712         $this->assertSame($records[1]->secondname, $this->records['test_table1'][0]->secondname);
1713         $this->assertSame($records[2]->intro, $this->records['test_table1'][1]->intro);
1715         // Collect statistics about the data in the temp table.
1716         $DB->update_temp_table_stats();
1718         // Drop table1.
1719         $dbman->drop_table($table1);
1720         $this->assertFalse($dbman->table_exists('test_table1'));
1722         // Try to drop non-existing temp table, must throw exception.
1723         $noetable = $this->tables['test_table1'];
1724         try {
1725             $dbman->drop_table($noetable);
1726             $this->fail('Exception expected');
1727         } catch (moodle_exception $e) {
1728             $this->assertInstanceOf('ddl_table_missing_exception', $e);
1729         }
1731         // Collect statistics about the data in the temp table with less tables.
1732         $DB->update_temp_table_stats();
1734         // Fill/modify/delete a few table0 records.
1736         // Drop table0.
1737         $dbman->drop_table($table0);
1738         $this->assertFalse($dbman->table_exists('test_table0'));
1740         // Create another temp table1.
1741         $table1 = $this->tables['test_table1'];
1742         $dbman->create_temp_table($table1);
1743         $this->assertTrue($dbman->table_exists('test_table1'));
1745         // Make sure it can be dropped using deprecated drop_temp_table().
1746         $dbman->drop_temp_table($table1);
1747         $this->assertFalse($dbman->table_exists('test_table1'));
1748         $this->assertDebuggingCalled();
1750         // Try join with normal tables - MS SQL may use incompatible collation.
1751         $table1 = new xmldb_table('test_table');
1752         $table1->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
1753         $table1->add_field('name', XMLDB_TYPE_CHAR, 255, null, XMLDB_NOTNULL, null);
1754         $table1->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
1755         $dbman->create_table($table1);
1757         $table2 = new xmldb_table('test_temp');
1758         $table2->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
1759         $table2->add_field('name', XMLDB_TYPE_CHAR, 255, null, XMLDB_NOTNULL, null);
1760         $table2->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
1761         $dbman->create_temp_table($table2);
1763         $record = array('name' => 'a');
1764         $DB->insert_record('test_table', $record);
1765         $DB->insert_record('test_temp', $record);
1767         $record = array('name' => 'b');
1768         $DB->insert_record('test_table', $record);
1770         $record = array('name' => 'c');
1771         $DB->insert_record('test_temp', $record);
1773         $sql = "SELECT *
1774                   FROM {test_table} n
1775                   JOIN {test_temp} t ON t.name = n.name";
1776         $records = $DB->get_records_sql($sql);
1777         $this->assertCount(1, $records);
1779         // Drop temp table.
1780         $dbman->drop_table($table2);
1781         $this->assertFalse($dbman->table_exists('test_temp'));
1782     }
1784     public function test_concurrent_temp_tables() {
1785         $DB = $this->tdb; // Do not use global $DB!
1786         $dbman = $this->tdb->get_manager();
1788         // Define 2 records.
1789         $record1 = (object)array(
1790             'course'     =>  1,
1791             'secondname' => '11 important',
1792             'intro'      => '111 important');
1793         $record2 = (object)array(
1794             'course'     =>  2,
1795             'secondname' => '22 important',
1796             'intro'      => '222 important');
1798         // Create temp table1 and insert 1 record (in DB).
1799         $table = $this->tables['test_table1'];
1800         $dbman->create_temp_table($table);
1801         $this->assertTrue($dbman->table_exists('test_table1'));
1802         $inserted = $DB->insert_record('test_table1', $record1);
1804         // Switch to new connection.
1805         $cfg = $DB->export_dbconfig();
1806         if (!isset($cfg->dboptions)) {
1807             $cfg->dboptions = array();
1808         }
1809         $DB2 = moodle_database::get_driver_instance($cfg->dbtype, $cfg->dblibrary);
1810         $DB2->connect($cfg->dbhost, $cfg->dbuser, $cfg->dbpass, $cfg->dbname, $cfg->prefix, $cfg->dboptions);
1811         $dbman2 = $DB2->get_manager();
1812         $this->assertFalse($dbman2->table_exists('test_table1')); // Temp table not exists in DB2.
1814         // Create temp table1 and insert 1 record (in DB2).
1815         $table = $this->tables['test_table1'];
1816         $dbman2->create_temp_table($table);
1817         $this->assertTrue($dbman2->table_exists('test_table1'));
1818         $inserted = $DB2->insert_record('test_table1', $record2);
1820         $dbman2->drop_table($table); // Drop temp table before closing DB2.
1821         $this->assertFalse($dbman2->table_exists('test_table1'));
1822         $DB2->dispose(); // Close DB2.
1824         $this->assertTrue($dbman->table_exists('test_table1')); // Check table continues existing for DB.
1825         $dbman->drop_table($table); // Drop temp table.
1826         $this->assertFalse($dbman->table_exists('test_table1'));
1827     }
1829     public function test_reset_sequence() {
1830         $DB = $this->tdb;
1831         $dbman = $DB->get_manager();
1833         $table = new xmldb_table('testtable');
1834         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
1835         $table->add_field('course', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, null, '0');
1836         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
1838         // Drop if exists.
1839         if ($dbman->table_exists($table)) {
1840             $dbman->drop_table($table);
1841         }
1842         $dbman->create_table($table);
1843         $tablename = $table->getName();
1844         $this->tables[$tablename] = $table;
1846         $record = (object)array('id'=>666, 'course'=>10);
1847         $DB->import_record('testtable', $record);
1848         $DB->delete_records('testtable'); // This delete performs one TRUNCATE.
1850         $dbman->reset_sequence($table); // Using xmldb object.
1851         $this->assertEquals(1, $DB->insert_record('testtable', (object)array('course'=>13)));
1853         $record = (object)array('id'=>666, 'course'=>10);
1854         $DB->import_record('testtable', $record);
1855         $DB->delete_records('testtable', array()); // This delete performs one DELETE.
1857         $dbman->reset_sequence($table); // Using xmldb object.
1858         $this->assertEquals(1, $DB->insert_record('testtable', (object)array('course'=>13)),
1859             'Some versions of MySQL 5.6.x are known to not support lowering of auto-increment numbers.');
1861         $DB->import_record('testtable', $record);
1862         $dbman->reset_sequence($tablename); // Using string.
1863         $this->assertEquals(667, $DB->insert_record('testtable', (object)array('course'=>13)));
1865         $dbman->drop_table($table);
1866     }
1868     public function test_reserved_words() {
1869         $reserved = sql_generator::getAllReservedWords();
1870         $this->assertTrue(count($reserved) > 1);
1871     }
1873     public function test_index_hints() {
1874         $DB = $this->tdb;
1875         $dbman = $DB->get_manager();
1877         $table = new xmldb_table('testtable');
1878         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
1879         $table->add_field('name', XMLDB_TYPE_CHAR, 255, null, XMLDB_NOTNULL, null);
1880         $table->add_field('path', XMLDB_TYPE_CHAR, 255, null, XMLDB_NOTNULL, null);
1881         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
1882         $table->add_index('name', XMLDB_INDEX_NOTUNIQUE, array('name'), array('xxxx,yyyy'));
1883         $table->add_index('path', XMLDB_INDEX_NOTUNIQUE, array('path'), array('varchar_pattern_ops'));
1885         // Drop if exists.
1886         if ($dbman->table_exists($table)) {
1887             $dbman->drop_table($table);
1888         }
1889         $dbman->create_table($table);
1890         $tablename = $table->getName();
1891         $this->tables[$tablename] = $table;
1893         $table = new xmldb_table('testtable');
1894         $index = new xmldb_index('name', XMLDB_INDEX_NOTUNIQUE, array('name'), array('xxxx,yyyy'));
1895         $this->assertTrue($dbman->index_exists($table, $index));
1897         $table = new xmldb_table('testtable');
1898         $index = new xmldb_index('path', XMLDB_INDEX_NOTUNIQUE, array('path'), array('varchar_pattern_ops'));
1899         $this->assertTrue($dbman->index_exists($table, $index));
1901         // Try unique indexes too.
1902         $dbman->drop_table($this->tables[$tablename]);
1904         $table = new xmldb_table('testtable');
1905         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
1906         $table->add_field('path', XMLDB_TYPE_CHAR, 255, null, XMLDB_NOTNULL, null);
1907         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
1908         $table->add_index('path', XMLDB_INDEX_UNIQUE, array('path'), array('varchar_pattern_ops'));
1909         $dbman->create_table($table);
1910         $this->tables[$tablename] = $table;
1912         $table = new xmldb_table('testtable');
1913         $index = new xmldb_index('path', XMLDB_INDEX_UNIQUE, array('path'), array('varchar_pattern_ops'));
1914         $this->assertTrue($dbman->index_exists($table, $index));
1915     }
1917     public function test_index_max_bytes() {
1918         $DB = $this->tdb;
1919         $dbman = $DB->get_manager();
1921         $maxstr = '';
1922         for ($i=0; $i<255; $i++) {
1923             $maxstr .= '言'; // Random long string that should fix exactly the limit for one char column.
1924         }
1926         $table = new xmldb_table('testtable');
1927         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
1928         $table->add_field('name', XMLDB_TYPE_CHAR, 255, null, XMLDB_NOTNULL, null);
1929         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
1930         $table->add_index('name', XMLDB_INDEX_NOTUNIQUE, array('name'));
1932         // Drop if exists.
1933         if ($dbman->table_exists($table)) {
1934             $dbman->drop_table($table);
1935         }
1936         $dbman->create_table($table);
1937         $tablename = $table->getName();
1938         $this->tables[$tablename] = $table;
1940         $rec = new stdClass();
1941         $rec->name = $maxstr;
1943         $id = $DB->insert_record($tablename, $rec);
1944         $this->assertTrue(!empty($id));
1946         $rec = $DB->get_record($tablename, array('id'=>$id));
1947         $this->assertSame($maxstr, $rec->name);
1949         $dbman->drop_table($table);
1951         $table = new xmldb_table('testtable');
1952         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
1953         $table->add_field('name', XMLDB_TYPE_CHAR, 255+1, null, XMLDB_NOTNULL, null);
1954         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
1955         $table->add_index('name', XMLDB_INDEX_NOTUNIQUE, array('name'));
1957         try {
1958             $dbman->create_table($table);
1959             $this->fail('Exception expected');
1960         } catch (moodle_exception $e) {
1961             $this->assertInstanceOf('coding_exception', $e);
1962         }
1963     }
1965     public function test_index_composed_max_bytes() {
1966         $DB = $this->tdb;
1967         $dbman = $DB->get_manager();
1969         $maxstr = '';
1970         for ($i=0; $i<200; $i++) {
1971             $maxstr .= '言';
1972         }
1973         $reststr = '';
1974         for ($i=0; $i<133; $i++) {
1975             $reststr .= '言';
1976         }
1978         $table = new xmldb_table('testtable');
1979         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
1980         $table->add_field('name1', XMLDB_TYPE_CHAR, 200, null, XMLDB_NOTNULL, null);
1981         $table->add_field('name2', XMLDB_TYPE_CHAR, 133, null, XMLDB_NOTNULL, null);
1982         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
1983         $table->add_index('name1-name2', XMLDB_INDEX_NOTUNIQUE, array('name1', 'name2'));
1985         // Drop if exists.
1986         if ($dbman->table_exists($table)) {
1987             $dbman->drop_table($table);
1988         }
1989         $dbman->create_table($table);
1990         $tablename = $table->getName();
1991         $this->tables[$tablename] = $table;
1993         $rec = new stdClass();
1994         $rec->name1 = $maxstr;
1995         $rec->name2 = $reststr;
1997         $id = $DB->insert_record($tablename, $rec);
1998         $this->assertTrue(!empty($id));
2000         $rec = $DB->get_record($tablename, array('id'=>$id));
2001         $this->assertSame($maxstr, $rec->name1);
2002         $this->assertSame($reststr, $rec->name2);
2004         $table = new xmldb_table('testtable');
2005         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
2006         $table->add_field('name1', XMLDB_TYPE_CHAR, 201, null, XMLDB_NOTNULL, null);
2007         $table->add_field('name2', XMLDB_TYPE_CHAR, 133, null, XMLDB_NOTNULL, null);
2008         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
2009         $table->add_index('name1-name2', XMLDB_INDEX_NOTUNIQUE, array('name1', 'name2'));
2011         // Drop if exists.
2012         if ($dbman->table_exists($table)) {
2013             $dbman->drop_table($table);
2014         }
2016         try {
2017             $dbman->create_table($table);
2018             $this->fail('Exception expected');
2019         } catch (moodle_exception $e) {
2020             $this->assertInstanceOf('coding_exception', $e);
2021         }
2022     }
2024     public function test_char_size_limit() {
2025         $DB = $this->tdb;
2026         $dbman = $DB->get_manager();
2028         $table = new xmldb_table('testtable');
2029         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
2030         $table->add_field('name', XMLDB_TYPE_CHAR, xmldb_field::CHAR_MAX_LENGTH, null, XMLDB_NOTNULL, null);
2031         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
2033         // Drop if exists.
2034         if ($dbman->table_exists($table)) {
2035             $dbman->drop_table($table);
2036         }
2037         $dbman->create_table($table);
2038         $tablename = $table->getName();
2039         $this->tables[$tablename] = $table;
2041         // This has to work in all DBs.
2042         $maxstr = '';
2043         for ($i=0; $i<xmldb_field::CHAR_MAX_LENGTH; $i++) {
2044             $maxstr .= 'a'; // Ascii only.
2045         }
2047         $rec = new stdClass();
2048         $rec->name = $maxstr;
2050         $id = $DB->insert_record($tablename, $rec);
2051         $this->assertTrue(!empty($id));
2053         $rec = $DB->get_record($tablename, array('id'=>$id));
2054         $this->assertSame($maxstr, $rec->name);
2056         // Following test is supposed to fail in oracle.
2057         $maxstr = '';
2058         for ($i=0; $i<xmldb_field::CHAR_MAX_LENGTH; $i++) {
2059             $maxstr .= '言'; // Random long string that should fix exactly the limit for one char column.
2060         }
2062         $rec = new stdClass();
2063         $rec->name = $maxstr;
2065         try {
2066             $id = $DB->insert_record($tablename, $rec);
2067             $this->assertTrue(!empty($id));
2069             $rec = $DB->get_record($tablename, array('id'=>$id));
2070             $this->assertSame($maxstr, $rec->name);
2071         } catch (dml_exception $e) {
2072             if ($DB->get_dbfamily() === 'oracle') {
2073                 $this->fail('Oracle does not support text fields larger than 4000 bytes, this is not a big problem for mostly ascii based languages');
2074             } else {
2075                 throw $e;
2076             }
2077         }
2079         $table = new xmldb_table('testtable');
2080         $table->add_field('id', XMLDB_TYPE_INTEGER, '10', null, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
2081         $table->add_field('name', XMLDB_TYPE_CHAR, xmldb_field::CHAR_MAX_LENGTH+1, null, XMLDB_NOTNULL, null);
2082         $table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
2084         // Drop if exists.
2085         if ($dbman->table_exists($table)) {
2086             $dbman->drop_table($table);
2087         }
2088         $tablename = $table->getName();
2089         $this->tables[$tablename] = $table;
2091         try {
2092             $dbman->create_table($table);
2093             $this->fail('Exception expected');
2094         } catch (moodle_exception $e) {
2095             $this->assertInstanceOf('coding_exception', $e);
2096         }
2097     }
2099     public function test_object_name() {
2100         $gen = $this->tdb->get_manager()->generator;
2102         // This will form short object name and max length should not be exceeded.
2103         $table = 'tablename';
2104         $fields = 'id';
2105         $suffix = 'pk';
2106         for ($i=0; $i<12; $i++) {
2107             $this->assertLessThanOrEqual($gen->names_max_length,
2108                     strlen($gen->getNameForObject($table, $fields, $suffix)),
2109                     'Generated object name is too long. $i = '.$i);
2110         }
2112         // This will form too long object name always and it must be trimmed to exactly 30 chars.
2113         $table = 'aaaa_bbbb_cccc_dddd_eeee_ffff_gggg';
2114         $fields = 'aaaaa,bbbbb,ccccc,ddddd';
2115         $suffix = 'idx';
2116         for ($i=0; $i<12; $i++) {
2117             $this->assertEquals($gen->names_max_length,
2118                     strlen($gen->getNameForObject($table, $fields, $suffix)),
2119                     'Generated object name is too long. $i = '.$i);
2120         }
2122         // Same test without suffix.
2123         $table = 'bbbb_cccc_dddd_eeee_ffff_gggg_hhhh';
2124         $fields = 'aaaaa,bbbbb,ccccc,ddddd';
2125         $suffix = '';
2126         for ($i=0; $i<12; $i++) {
2127             $this->assertEquals($gen->names_max_length,
2128                     strlen($gen->getNameForObject($table, $fields, $suffix)),
2129                     'Generated object name is too long. $i = '.$i);
2130         }
2132         // This must only trim name when counter is 10 or more.
2133         $table = 'cccc_dddd_eeee_ffff_gggg_hhhh_iiii';
2134         $fields = 'id';
2135         $suffix = 'idx';
2136         // Since we don't know how long prefix is, loop to generate tablename that gives exactly maxlengh-1 length.
2137         // Skip this test if prefix is too long.
2138         while (strlen($table) && strlen($gen->prefix.preg_replace('/_/','',$table).'_id_'.$suffix) >= $gen->names_max_length) {
2139             $table = rtrim(substr($table, 0, strlen($table) - 1), '_');
2140         }
2141         if (strlen($table)) {
2142             $this->assertEquals($gen->names_max_length - 1,
2143                         strlen($gen->getNameForObject($table, $fields, $suffix)));
2144             for ($i=0; $i<12; $i++) {
2145                 $this->assertEquals($gen->names_max_length,
2146                         strlen($gen->getNameForObject($table, $fields, $suffix)),
2147                         'Generated object name is too long. $i = '.$i);
2148             }
2150             // Now test to confirm that a duplicate name isn't issued, even if they come from different root names.
2151             // Move to a new field.
2152             $fields = "fl";
2154             // Insert twice, moving is to a key with fl2.
2155             $this->assertEquals($gen->names_max_length - 1, strlen($gen->getNameForObject($table, $fields, $suffix)));
2156             $result1 = $gen->getNameForObject($table, $fields, $suffix);
2158             // Make sure we end up with _fl2_ in the result.
2159             $this->assertRegExp('/_fl2_/', $result1);
2161             // Now, use a field that would result in the same key if it wasn't already taken.
2162             $fields = "fl2";
2163             // Because we are now at the max key length, it will try:
2164             // - _fl2_ (the natural name)
2165             // - _fl2_ (removing the original 2, and adding a counter 2)
2166             // - then settle on _fl3_.
2167             $result2 = $gen->getNameForObject($table, $fields, $suffix);
2168             $this->assertRegExp('/_fl3_/', $result2);
2170             // Make sure they don't match.
2171             $this->assertNotEquals($result1, $result2);
2172             // But are only different in the way we expect. This confirms the test is working properly.
2173             $this->assertEquals(str_replace('_fl2_', '', $result1), str_replace('_fl3_', '', $result2));
2175             // Now go back. We would expect the next result to be fl3 again, but it is taken, so it should move to fl4.
2176             $fields = "fl";
2177             $result3 = $gen->getNameForObject($table, $fields, $suffix);
2179             $this->assertNotEquals($result2, $result3);
2180             $this->assertRegExp('/_fl4_/', $result3);
2181         }
2182     }
2184     /**
2185      * Data provider for test_get_enc_quoted().
2186      *
2187      * @return array The type-value pair fixture.
2188      */
2189     public function test_get_enc_quoted_provider() {
2190         return array(
2191             // Reserved: some examples from SQL-92.
2192             [true, 'from'],
2193             [true, 'table'],
2194             [true, 'where'],
2195             // Not reserved.
2196             [false, 'my_awesome_column_name']
2197         );
2198     }
2200     /**
2201      * This is a test for sql_generator::getEncQuoted().
2202      *
2203      * @dataProvider test_get_enc_quoted_provider
2204      * @param bool $reserved Whether the column name is reserved or not.
2205      * @param string $columnname The column name to be quoted, according to the value of $reserved.
2206      **/
2207     public function test_get_enc_quoted($reserved, $columnname) {
2208         $DB = $this->tdb;
2209         $gen = $DB->get_manager()->generator;
2211         if (!$reserved) {
2212             // No need to quote the column name.
2213             $this->assertSame($columnname, $gen->getEncQuoted($columnname));
2214         } else {
2215             // Column name should be quoted.
2216             $dbfamily = $DB->get_dbfamily();
2218             switch ($dbfamily) {
2219                 case 'mysql':
2220                     $this->assertSame("`$columnname`", $gen->getEncQuoted($columnname));
2221                     break;
2222                 case 'mssql': // The Moodle connection runs under 'QUOTED_IDENTIFIER ON'.
2223                 case 'oracle':
2224                 case 'postgres':
2225                 case 'sqlite':
2226                 default:
2227                     $this->assertSame('"' . $columnname . '"', $gen->getEncQuoted($columnname));
2228                     break;
2229             }
2230         }
2231     }
2233     /**
2234      * Data provider for test_sql_generator_get_rename_field_sql().
2235      *
2236      * @return array The type-old-new tuple fixture.
2237      */
2238     public function test_sql_generator_get_rename_field_sql_provider() {
2239         return array(
2240             // Reserved: an example from SQL-92.
2241             // Both names should be reserved.
2242             [true, 'from', 'where'],
2243             // Not reserved.
2244             [false, 'my_old_column_name', 'my_awesome_column_name']
2245         );
2246     }
2248     /**
2249      * This is a unit test for sql_generator::getRenameFieldSQL().
2250      *
2251      * @dataProvider test_sql_generator_get_rename_field_sql_provider
2252      * @param bool $reserved Whether the column name is reserved or not.
2253      * @param string $oldcolumnname The column name to be renamed.
2254      * @param string $newcolumnname The new column name.
2255      **/
2256     public function test_sql_generator_get_rename_field_sql($reserved, $oldcolumnname, $newcolumnname) {
2257         $DB = $this->tdb;
2258         $gen = $DB->get_manager()->generator;
2259         $prefix = $DB->get_prefix();
2261         $tablename = 'test_get_rename_field_sql';
2262         $table = new xmldb_table($tablename);
2263         $field = new xmldb_field($oldcolumnname, XMLDB_TYPE_INTEGER, '11', null, XMLDB_NOTNULL, null, null, null, '0', 'previous');
2265         $dbfamily = $DB->get_dbfamily();
2266         if (!$reserved) {
2267             // No need to quote the column name.
2268             switch ($dbfamily) {
2269                 case 'mysql':
2270                     $this->assertSame(
2271                         [ "ALTER TABLE {$prefix}$tablename CHANGE $oldcolumnname $newcolumnname BIGINT(11) NOT NULL" ],
2272                         $gen->getRenameFieldSQL($table, $field, $newcolumnname)
2273                     );
2274                     break;
2275                 case 'sqlite':
2276                     // Skip it, since the DB is not supported yet.
2277                     // BTW renaming a column name is already covered by the integration test 'testRenameField'.
2278                     break;
2279                 case 'mssql': // The Moodle connection runs under 'QUOTED_IDENTIFIER ON'.
2280                     $this->assertSame(
2281                         [ "sp_rename '{$prefix}$tablename.[$oldcolumnname]', '$newcolumnname', 'COLUMN'" ],
2282                         $gen->getRenameFieldSQL($table, $field, $newcolumnname)
2283                     );
2284                     break;
2285                 case 'oracle':
2286                 case 'postgres':
2287                 default:
2288                     $this->assertSame(
2289                         [ "ALTER TABLE {$prefix}$tablename RENAME COLUMN $oldcolumnname TO $newcolumnname" ],
2290                         $gen->getRenameFieldSQL($table, $field, $newcolumnname)
2291                     );
2292                     break;
2293             }
2294         } else {
2295             // Column name should be quoted.
2296             switch ($dbfamily) {
2297                 case 'mysql':
2298                     $this->assertSame(
2299                         [ "ALTER TABLE {$prefix}$tablename CHANGE `$oldcolumnname` `$newcolumnname` BIGINT(11) NOT NULL" ],
2300                         $gen->getRenameFieldSQL($table, $field, $newcolumnname)
2301                     );
2302                     break;
2303                 case 'sqlite':
2304                     // Skip it, since the DB is not supported yet.
2305                     // BTW renaming a column name is already covered by the integration test 'testRenameField'.
2306                 break;
2307                 case 'mssql': // The Moodle connection runs under 'QUOTED_IDENTIFIER ON'.
2308                     $this->assertSame(
2309                         [ "sp_rename '{$prefix}$tablename.[$oldcolumnname]', '$newcolumnname', 'COLUMN'" ],
2310                         $gen->getRenameFieldSQL($table, $field, $newcolumnname)
2311                     );
2312                     break;
2313                 case 'oracle':
2314                 case 'postgres':
2315                 default:
2316                     $this->assertSame(
2317                         [ "ALTER TABLE {$prefix}$tablename RENAME COLUMN \"$oldcolumnname\" TO \"$newcolumnname\"" ],
2318                         $gen->getRenameFieldSQL($table, $field, $newcolumnname)
2319                     );
2320                     break;
2321             }
2322         }
2323     }
2325     // Following methods are not supported == Do not test.
2326     /*
2327         public function testRenameIndex() {
2328             // Unsupported!
2329             $dbman = $this->tdb->get_manager();
2331             $table = $this->create_deftable('test_table0');
2332             $index = new xmldb_index('course');
2333             $index->set_attributes(XMLDB_INDEX_UNIQUE, array('course'));
2335             $this->assertTrue($dbman->rename_index($table, $index, 'newindexname'));
2336         }
2338         public function testRenameKey() {
2339             // Unsupported!
2340              $dbman = $this->tdb->get_manager();
2342             $table = $this->create_deftable('test_table0');
2343             $key = new xmldb_key('course');
2344             $key->set_attributes(XMLDB_KEY_UNIQUE, array('course'));
2346             $this->assertTrue($dbman->rename_key($table, $key, 'newkeyname'));
2347         }
2348     */