mirror of
https://github.com/moodle/moodle.git
synced 2025-08-05 08:56:36 +02:00
1971 lines
79 KiB
PHP
Executable file
1971 lines
79 KiB
PHP
Executable file
<?php
|
|
/**
|
|
* Unit tests for dml
|
|
* @package dml
|
|
*/
|
|
|
|
if (!defined('MOODLE_INTERNAL')) {
|
|
die('Direct access to this script is forbidden.'); /// It must be included from a Moodle page
|
|
}
|
|
|
|
class dml_test extends UnitTestCase {
|
|
private $tables = array();
|
|
private $tdb;
|
|
private $data;
|
|
|
|
function setUp() {
|
|
global $CFG, $DB, $UNITTEST;
|
|
|
|
if (isset($UNITTEST->func_test_db)) {
|
|
$this->tdb = $UNITTEST->func_test_db;
|
|
} else {
|
|
$this->tdb = $DB;
|
|
}
|
|
|
|
}
|
|
|
|
function tearDown() {
|
|
$dbman = $this->tdb->get_manager();
|
|
|
|
foreach ($this->tables as $table) {
|
|
if ($dbman->table_exists($table)) {
|
|
$dbman->drop_table($table);
|
|
}
|
|
}
|
|
$this->tables = array();
|
|
}
|
|
|
|
/**
|
|
* Get a xmldb_table object for testing, deleting any existing table
|
|
* of the same name, for example if one was left over from a previous test
|
|
* run that crashed.
|
|
*
|
|
* @param database_manager $dbman the database_manager to use.
|
|
* @param string $tablename the name of the table to create.
|
|
* @return xmldb_table the table object.
|
|
*/
|
|
private function get_test_table($tablename="") {
|
|
$dbman = $this->tdb->get_manager();
|
|
|
|
if ($tablename === "") {
|
|
if (defined('OCI_HACKERY')) {
|
|
static $i = 0;
|
|
$tablename = "unit_table".$i++;
|
|
} else {
|
|
$tablename = "unit_table";
|
|
}
|
|
}
|
|
|
|
$table = new xmldb_table($tablename);
|
|
if ($dbman->table_exists($table)) {
|
|
$dbman->drop_table($table);
|
|
}
|
|
return new xmldb_table($tablename);
|
|
}
|
|
|
|
function test_fix_sql_params() {
|
|
$DB = $this->tdb;
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
// Correct table placeholder substitution
|
|
$sql = "SELECT * FROM {".$tablename."}";
|
|
$sqlarray = $DB->fix_sql_params($sql);
|
|
$this->assertEqual("SELECT * FROM {$DB->get_prefix()}".$tablename, $sqlarray[0]);
|
|
|
|
// Conversions of all param types
|
|
$sql = array();
|
|
$sql[SQL_PARAMS_NAMED] = "SELECT * FROM {$DB->get_prefix()}testtable WHERE name = :param1, course = :param2";
|
|
$sql[SQL_PARAMS_QM] = "SELECT * FROM {$DB->get_prefix()}testtable WHERE name = ?, course = ?";
|
|
$sql[SQL_PARAMS_DOLLAR] = "SELECT * FROM {$DB->get_prefix()}testtable WHERE name = \$1, course = \$2";
|
|
|
|
$params = array();
|
|
$params[SQL_PARAMS_NAMED] = array('param1'=>'first record', 'param2'=>1);
|
|
$params[SQL_PARAMS_QM] = array('first record', 1);
|
|
$params[SQL_PARAMS_DOLLAR] = array('first record', 1);
|
|
|
|
list($rsql, $rparams, $rtype) = $DB->fix_sql_params($sql[SQL_PARAMS_NAMED], $params[SQL_PARAMS_NAMED]);
|
|
$this->assertEqual($rsql, $sql[$rtype]);
|
|
$this->assertEqual($rparams, $params[$rtype]);
|
|
|
|
list($rsql, $rparams, $rtype) = $DB->fix_sql_params($sql[SQL_PARAMS_QM], $params[SQL_PARAMS_QM]);
|
|
$this->assertEqual($rsql, $sql[$rtype]);
|
|
$this->assertEqual($rparams, $params[$rtype]);
|
|
|
|
list($rsql, $rparams, $rtype) = $DB->fix_sql_params($sql[SQL_PARAMS_DOLLAR], $params[SQL_PARAMS_DOLLAR]);
|
|
$this->assertEqual($rsql, $sql[$rtype]);
|
|
$this->assertEqual($rparams, $params[$rtype]);
|
|
|
|
|
|
// Malformed table placeholder
|
|
$sql = "SELECT * FROM [testtable]";
|
|
$sqlarray = $DB->fix_sql_params($sql);
|
|
$this->assertEqual($sql, $sqlarray[0]);
|
|
|
|
|
|
// Mixed param types (colon and dollar)
|
|
$sql = "SELECT * FROM {".$tablename."} WHERE name = :param1, course = \$1";
|
|
$params = array('param1' => 'record1', 'param2' => 3);
|
|
try {
|
|
$sqlarray = $DB->fix_sql_params($sql, $params);
|
|
$this->fail("Expecting an exception, none occurred");
|
|
} catch (Exception $e) {
|
|
$this->assertTrue($e instanceof moodle_exception);
|
|
}
|
|
|
|
// Mixed param types (question and dollar)
|
|
$sql = "SELECT * FROM {".$tablename."} WHERE name = ?, course = \$1";
|
|
$params = array('param1' => 'record2', 'param2' => 5);
|
|
try {
|
|
$sqlarray = $DB->fix_sql_params($sql, $params);
|
|
$this->fail("Expecting an exception, none occurred");
|
|
} catch (Exception $e) {
|
|
$this->assertTrue($e instanceof moodle_exception);
|
|
}
|
|
|
|
// Too many params in sql
|
|
$sql = "SELECT * FROM {".$tablename."} WHERE name = ?, course = ?, id = ?";
|
|
$params = array('record2', 3);
|
|
try {
|
|
$sqlarray = $DB->fix_sql_params($sql, $params);
|
|
$this->fail("Expecting an exception, none occurred");
|
|
} catch (Exception $e) {
|
|
$this->assertTrue($e instanceof moodle_exception);
|
|
}
|
|
|
|
// Too many params in array: no error
|
|
$params[] = 1;
|
|
$params[] = time();
|
|
$sqlarray = null;
|
|
|
|
try {
|
|
$sqlarray = $DB->fix_sql_params($sql, $params);
|
|
$this->pass();
|
|
} catch (Exception $e) {
|
|
$this->fail("Unexpected ".get_class($e)." exception");
|
|
}
|
|
$this->assertTrue($sqlarray[0]);
|
|
|
|
// Named params missing from array
|
|
$sql = "SELECT * FROM {".$tablename."} WHERE name = :name, course = :course";
|
|
$params = array('wrongname' => 'record1', 'course' => 1);
|
|
try {
|
|
$sqlarray = $DB->fix_sql_params($sql, $params);
|
|
$this->fail("Expecting an exception, none occurred");
|
|
} catch (Exception $e) {
|
|
$this->assertTrue($e instanceof moodle_exception);
|
|
}
|
|
|
|
// Duplicate named param in query
|
|
$sql = "SELECT * FROM {".$tablename."} WHERE name = :name, course = :name";
|
|
$params = array('name' => 'record2', 'course' => 3);
|
|
try {
|
|
$sqlarray = $DB->fix_sql_params($sql, $params);
|
|
$this->fail("Expecting an exception, none occurred");
|
|
} catch (Exception $e) {
|
|
$this->assertTrue($e instanceof moodle_exception);
|
|
}
|
|
|
|
}
|
|
|
|
public function testGetTables() {
|
|
$DB = $this->tdb;
|
|
$dbman = $this->tdb->get_manager();
|
|
|
|
// Need to test with multiple DBs
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$original_count = count($DB->get_tables());
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$this->assertTrue(count($DB->get_tables()) == $original_count + 1);
|
|
}
|
|
|
|
public function testDefaults() {
|
|
$DB = $this->tdb;
|
|
$dbman = $this->tdb->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('enumfield', XMLDB_TYPE_CHAR, '255', null, XMLDB_NOTNULL, null, 'test2');
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$columns = $DB->get_columns($tablename);
|
|
|
|
$enumfield = $columns['enumfield'];
|
|
$this->assertEqual('test2', $enumfield->default_value);
|
|
$this->assertEqual('C', $enumfield->meta_type);
|
|
|
|
}
|
|
|
|
public function testGetIndexes() {
|
|
$DB = $this->tdb;
|
|
$dbman = $this->tdb->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$table->add_index('course', XMLDB_INDEX_NOTUNIQUE, array('course'));
|
|
$table->add_index('course-id', XMLDB_INDEX_UNIQUE, array('course', 'id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$this->assertTrue($indices = $DB->get_indexes($tablename));
|
|
$this->assertEqual(count($indices), 2);
|
|
// we do not care about index names for now
|
|
$first = array_shift($indices);
|
|
$second = array_shift($indices);
|
|
if (count($first['columns']) == 2) {
|
|
$composed = $first;
|
|
$single = $second;
|
|
} else {
|
|
$composed = $second;
|
|
$single = $first;
|
|
}
|
|
$this->assertFalse($single['unique']);
|
|
$this->assertTrue($composed['unique']);
|
|
$this->assertEqual(1, count($single['columns']));
|
|
$this->assertEqual(2, count($composed['columns']));
|
|
$this->assertEqual('course', $single['columns'][0]);
|
|
$this->assertEqual('course', $composed['columns'][0]);
|
|
$this->assertEqual('id', $composed['columns'][1]);
|
|
}
|
|
|
|
public function testGetColumns() {
|
|
$DB = $this->tdb;
|
|
$dbman = $this->tdb->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_field('name', XMLDB_TYPE_CHAR, '255', null, null, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$this->assertTrue($columns = $DB->get_columns($tablename));
|
|
$fields = $this->tables[$tablename]->getFields();
|
|
$this->assertEqual(count($columns), count($fields));
|
|
|
|
for ($i = 0; $i < count($columns); $i++) {
|
|
if ($i == 0) {
|
|
$next_column = reset($columns);
|
|
$next_field = reset($fields);
|
|
} else {
|
|
$next_column = next($columns);
|
|
$next_field = next($fields);
|
|
}
|
|
|
|
$this->assertEqual($next_column->name, $next_field->name);
|
|
}
|
|
}
|
|
|
|
public function testExecute() {
|
|
$DB = $this->tdb;
|
|
$dbman = $this->tdb->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_field('name', XMLDB_TYPE_CHAR, '255', null, null, null, '0');
|
|
$table->add_index('course', XMLDB_INDEX_NOTUNIQUE, array('course'));
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$sql = "SELECT * FROM {".$tablename."}";
|
|
|
|
$this->assertTrue($DB->execute($sql));
|
|
|
|
$params = array('course' => 1, 'name' => 'test');
|
|
|
|
$sql = "INSERT INTO {".$tablename."} (".implode(',', array_keys($params)).")
|
|
VALUES (".implode(',', array_fill(0, count($params), '?')).")";
|
|
|
|
|
|
$this->assertTrue($DB->execute($sql, $params));
|
|
|
|
$record = $DB->get_record($tablename, array('id' => 1));
|
|
|
|
foreach ($params as $field => $value) {
|
|
$this->assertEqual($value, $record->$field, "Field $field in DB ({$record->$field}) is not equal to field $field in sql ($value)");
|
|
}
|
|
}
|
|
|
|
public function test_get_in_or_equal() {
|
|
$DB = $this->tdb;
|
|
|
|
// SQL_PARAMS_QM - IN or =
|
|
|
|
// Correct usage of multiple values
|
|
$in_values = array('value1', 'value2', 'value3', 'value4');
|
|
list($usql, $params) = $DB->get_in_or_equal($in_values);
|
|
$this->assertEqual("IN (?,?,?,?)", $usql);
|
|
$this->assertEqual(4, count($params));
|
|
foreach ($params as $key => $value) {
|
|
$this->assertEqual($in_values[$key], $value);
|
|
}
|
|
|
|
// Correct usage of single value (in an array)
|
|
$in_values = array('value1');
|
|
list($usql, $params) = $DB->get_in_or_equal($in_values);
|
|
$this->assertEqual("= ?", $usql);
|
|
$this->assertEqual(1, count($params));
|
|
$this->assertEqual($in_values[0], $params[0]);
|
|
|
|
// Correct usage of single value
|
|
$in_value = 'value1';
|
|
list($usql, $params) = $DB->get_in_or_equal($in_values);
|
|
$this->assertEqual("= ?", $usql);
|
|
$this->assertEqual(1, count($params));
|
|
$this->assertEqual($in_value, $params[0]);
|
|
|
|
// SQL_PARAMS_QM - NOT IN or <>
|
|
|
|
// Correct usage of multiple values
|
|
$in_values = array('value1', 'value2', 'value3', 'value4');
|
|
list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_QM, null, false);
|
|
$this->assertEqual("NOT IN (?,?,?,?)", $usql);
|
|
$this->assertEqual(4, count($params));
|
|
foreach ($params as $key => $value) {
|
|
$this->assertEqual($in_values[$key], $value);
|
|
}
|
|
|
|
// Correct usage of single value (in array()
|
|
$in_values = array('value1');
|
|
list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_QM, null, false);
|
|
$this->assertEqual("<> ?", $usql);
|
|
$this->assertEqual(1, count($params));
|
|
$this->assertEqual($in_values[0], $params[0]);
|
|
|
|
// Correct usage of single value
|
|
$in_value = 'value1';
|
|
list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_QM, null, false);
|
|
$this->assertEqual("<> ?", $usql);
|
|
$this->assertEqual(1, count($params));
|
|
$this->assertEqual($in_value, $params[0]);
|
|
|
|
// SQL_PARAMS_NAMED - IN or =
|
|
|
|
// Correct usage of multiple values
|
|
$in_values = array('value1', 'value2', 'value3', 'value4');
|
|
list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_NAMED, 'param01', true);
|
|
$this->assertEqual("IN (:param01,:param02,:param03,:param04)", $usql);
|
|
$this->assertEqual(4, count($params));
|
|
reset($in_values);
|
|
foreach ($params as $key => $value) {
|
|
$this->assertEqual(current($in_values), $value);
|
|
next($in_values);
|
|
}
|
|
|
|
// Correct usage of single values (in array)
|
|
$in_values = array('value1');
|
|
list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_NAMED, 'param01', true);
|
|
$this->assertEqual("= :param01", $usql);
|
|
$this->assertEqual(1, count($params));
|
|
$this->assertEqual($in_values[0], $params['param01']);
|
|
|
|
// Correct usage of single value
|
|
$in_value = 'value1';
|
|
list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_NAMED, 'param01', true);
|
|
$this->assertEqual("= :param01", $usql);
|
|
$this->assertEqual(1, count($params));
|
|
$this->assertEqual($in_value, $params['param01']);
|
|
|
|
// SQL_PARAMS_NAMED - NOT IN or <>
|
|
|
|
// Correct usage of multiple values
|
|
$in_values = array('value1', 'value2', 'value3', 'value4');
|
|
list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_NAMED, 'param01', false);
|
|
$this->assertEqual("NOT IN (:param01,:param02,:param03,:param04)", $usql);
|
|
$this->assertEqual(4, count($params));
|
|
reset($in_values);
|
|
foreach ($params as $key => $value) {
|
|
$this->assertEqual(current($in_values), $value);
|
|
next($in_values);
|
|
}
|
|
|
|
// Correct usage of single values (in array)
|
|
$in_values = array('value1');
|
|
list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_NAMED, 'param01', false);
|
|
$this->assertEqual("<> :param01", $usql);
|
|
$this->assertEqual(1, count($params));
|
|
$this->assertEqual($in_values[0], $params['param01']);
|
|
|
|
// Correct usage of single value
|
|
$in_value = 'value1';
|
|
list($usql, $params) = $DB->get_in_or_equal($in_values, SQL_PARAMS_NAMED, 'param01', false);
|
|
$this->assertEqual("<> :param01", $usql);
|
|
$this->assertEqual(1, count($params));
|
|
$this->assertEqual($in_value, $params['param01']);
|
|
|
|
}
|
|
|
|
public function test_fix_table_names() {
|
|
$DB = new moodle_database_for_testing();
|
|
$prefix = $DB->get_prefix();
|
|
|
|
// Simple placeholder
|
|
$placeholder = "{user}";
|
|
$this->assertEqual($prefix."user", $DB->public_fix_table_names($placeholder));
|
|
|
|
// Full SQL
|
|
$sql = "SELECT * FROM {user}, {funny_table_name}, {mdl_stupid_table} WHERE {user}.id = {funny_table_name}.userid";
|
|
$expected = "SELECT * FROM {$prefix}user, {$prefix}funny_table_name, {$prefix}mdl_stupid_table WHERE {$prefix}user.id = {$prefix}funny_table_name.userid";
|
|
$this->assertEqual($expected, $DB->public_fix_table_names($sql));
|
|
|
|
|
|
}
|
|
|
|
public function test_get_recordset() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_field('name', XMLDB_TYPE_CHAR, '255', null, null, null, '0');
|
|
$table->add_index('course', XMLDB_INDEX_NOTUNIQUE, array('course'));
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$data = array(array('id' => 1, 'course' => 3, 'name' => 'record1'),
|
|
array('id' => 2, 'course' => 3, 'name' => 'record2'),
|
|
array('id' => 3, 'course' => 5, 'name' => 'record3'));
|
|
|
|
foreach ($data as $record) {
|
|
$DB->insert_record($tablename, $record);
|
|
}
|
|
|
|
$rs = $DB->get_recordset($tablename);
|
|
$this->assertTrue($rs);
|
|
|
|
reset($data);
|
|
foreach($rs as $record) {
|
|
$data_record = current($data);
|
|
foreach ($record as $k => $v) {
|
|
$this->assertEqual($data_record[$k], $v);
|
|
}
|
|
next($data);
|
|
}
|
|
$rs->close();
|
|
}
|
|
|
|
public function test_get_recordset_iterator_keys() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_field('name', XMLDB_TYPE_CHAR, '255', null, null, null, '0');
|
|
$table->add_index('course', XMLDB_INDEX_NOTUNIQUE, array('course'));
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$data = array(array('id'=> 1, 'course' => 3, 'name' => 'record1'),
|
|
array('id'=> 2, 'course' => 3, 'name' => 'record2'),
|
|
array('id'=> 3, 'course' => 5, 'name' => 'record3'));
|
|
foreach ($data as $record) {
|
|
$DB->insert_record($tablename, $record);
|
|
}
|
|
|
|
/// Test repeated numeric keys are returned ok
|
|
$rs = $DB->get_recordset($tablename, NULL, NULL, 'course, name, id');
|
|
|
|
reset($data);
|
|
$count = 0;
|
|
foreach($rs as $key => $record) {
|
|
$data_record = current($data);
|
|
$this->assertEqual($data_record['course'], $key);
|
|
next($data);
|
|
$count++;
|
|
}
|
|
$rs->close();
|
|
|
|
/// Test record returned are ok
|
|
$this->assertEqual($count, 3);
|
|
|
|
/// Test string keys are returned ok
|
|
$rs = $DB->get_recordset($tablename, NULL, NULL, 'name, course, id');
|
|
|
|
reset($data);
|
|
$count = 0;
|
|
foreach($rs as $key => $record) {
|
|
$data_record = current($data);
|
|
$this->assertEqual($data_record['name'], $key);
|
|
next($data);
|
|
$count++;
|
|
}
|
|
$rs->close();
|
|
|
|
/// Test record returned are ok
|
|
$this->assertEqual($count, 3);
|
|
|
|
/// Test numeric not starting in 1 keys are returned ok
|
|
$rs = $DB->get_recordset($tablename, NULL, 'id DESC', 'id, course, name');
|
|
|
|
$data = array_reverse($data);
|
|
reset($data);
|
|
$count = 0;
|
|
foreach($rs as $key => $record) {
|
|
$data_record = current($data);
|
|
$this->assertEqual($data_record['id'], $key);
|
|
next($data);
|
|
$count++;
|
|
}
|
|
$rs->close();
|
|
|
|
/// Test record returned are ok
|
|
$this->assertEqual($count, 3);
|
|
}
|
|
|
|
public function test_get_recordset_list() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_index('course', XMLDB_INDEX_NOTUNIQUE, array('course'));
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 5));
|
|
$DB->insert_record($tablename, array('course' => 2));
|
|
|
|
$rs = $DB->get_recordset_list($tablename, 'course', array(3, 2));
|
|
|
|
$this->assertTrue($rs);
|
|
|
|
$counter = 0;
|
|
foreach ($rs as $record) {
|
|
$counter++;
|
|
}
|
|
$this->assertEqual(3, $counter);
|
|
$rs->close();
|
|
|
|
$rs = $DB->get_recordset_list($tablename, 'course',array()); /// Must return 0 rows without conditions. MDL-17645
|
|
|
|
$counter = 0;
|
|
foreach ($rs as $record) {
|
|
$counter++;
|
|
}
|
|
$this->assertEqual(0, $counter);
|
|
$rs->close();
|
|
}
|
|
|
|
public function test_get_recordset_select() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 5));
|
|
$DB->insert_record($tablename, array('course' => 2));
|
|
|
|
$rs = $DB->get_recordset_select($tablename, '');
|
|
$counter = 0;
|
|
foreach ($rs as $record) {
|
|
$counter++;
|
|
}
|
|
$this->assertEqual(4, $counter);
|
|
|
|
$this->assertTrue($rs = $DB->get_recordset_select($tablename, 'course = 3'));
|
|
$counter = 0;
|
|
foreach ($rs as $record) {
|
|
$counter++;
|
|
}
|
|
$this->assertEqual(2, $counter);
|
|
}
|
|
|
|
public function test_get_recordset_sql() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 5));
|
|
$DB->insert_record($tablename, array('course' => 2));
|
|
|
|
$this->assertTrue($rs = $DB->get_recordset_sql("SELECT * FROM {".$tablename."} WHERE course = ?", array(3)));
|
|
$counter = 0;
|
|
foreach ($rs as $record) {
|
|
$counter++;
|
|
}
|
|
$this->assertEqual(2, $counter);
|
|
}
|
|
|
|
public function test_get_records() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 5));
|
|
$DB->insert_record($tablename, array('course' => 2));
|
|
|
|
// All records
|
|
$records = $DB->get_records($tablename);
|
|
$this->assertEqual(4, count($records));
|
|
$this->assertEqual(3, $records[1]->course);
|
|
$this->assertEqual(3, $records[2]->course);
|
|
$this->assertEqual(5, $records[3]->course);
|
|
$this->assertEqual(2, $records[4]->course);
|
|
|
|
// Records matching certain conditions
|
|
$records = $DB->get_records($tablename, array('course' => 3));
|
|
$this->assertEqual(2, count($records));
|
|
$this->assertEqual(3, $records[1]->course);
|
|
$this->assertEqual(3, $records[2]->course);
|
|
|
|
// All records sorted by course
|
|
$records = $DB->get_records($tablename, null, 'course');
|
|
$this->assertEqual(4, count($records));
|
|
$current_record = reset($records);
|
|
$this->assertEqual(4, $current_record->id);
|
|
$current_record = next($records);
|
|
$this->assertEqual(1, $current_record->id);
|
|
$current_record = next($records);
|
|
$this->assertEqual(2, $current_record->id);
|
|
$current_record = next($records);
|
|
$this->assertEqual(3, $current_record->id);
|
|
|
|
// All records, but get only one field
|
|
$records = $DB->get_records($tablename, null, '', 'id');
|
|
$this->assertTrue(empty($records[1]->course));
|
|
$this->assertFalse(empty($records[1]->id));
|
|
$this->assertEqual(4, count($records));
|
|
|
|
// test limitfrom and limitnum
|
|
$records = $DB->get_records($tablename, null, '', 'id', 0, 0);
|
|
$this->assertEqual(4, count($records));
|
|
$records = $DB->get_records($tablename, null, '', 'id', -1, -1);
|
|
$this->assertEqual(4, count($records));
|
|
$records = $DB->get_records($tablename, null, '', 'id', 2, 2);
|
|
$this->assertEqual(2, count($records));
|
|
$first = reset($records);
|
|
$last = array_pop($records);
|
|
$this->assertEqual(3, $first->id);
|
|
$this->assertEqual(4, $last->id);
|
|
|
|
// TODO: more LIMIT tests
|
|
}
|
|
|
|
public function test_get_records_list() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 5));
|
|
$DB->insert_record($tablename, array('course' => 2));
|
|
|
|
$this->assertTrue($records = $DB->get_records_list($tablename, 'course', array(3, 2)));
|
|
$this->assertEqual(3, count($records));
|
|
$this->assertEqual(1, reset($records)->id);
|
|
$this->assertEqual(2, next($records)->id);
|
|
$this->assertEqual(4, next($records)->id);
|
|
|
|
$this->assertIdentical(array(), $records = $DB->get_records_list($tablename, 'course', array())); /// Must return 0 rows without conditions. MDL-17645
|
|
$this->assertEqual(0, count($records));
|
|
|
|
}
|
|
|
|
public function test_get_records_sql() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 5));
|
|
$DB->insert_record($tablename, array('course' => 2));
|
|
|
|
$this->assertTrue($records = $DB->get_records_sql("SELECT * FROM {".$tablename."} WHERE course = ?", array(3)));
|
|
$this->assertEqual(2, count($records));
|
|
$this->assertEqual(1, reset($records)->id);
|
|
$this->assertEqual(2, next($records)->id);
|
|
|
|
ob_start(); // hide debug warning
|
|
$records = $DB->get_records_sql("SELECT course AS id, course AS course FROM {".$tablename."}", null);
|
|
$debuginfo = ob_get_contents();
|
|
ob_end_clean();
|
|
|
|
$this->assertEqual(3, count($records));
|
|
$this->assertFalse($debuginfo === '');
|
|
}
|
|
|
|
public function test_get_records_menu() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 5));
|
|
$DB->insert_record($tablename, array('course' => 2));
|
|
|
|
$this->assertTrue($records = $DB->get_records_menu($tablename, array('course' => 3)));
|
|
$this->assertEqual(2, count($records));
|
|
$this->assertFalse(empty($records[1]));
|
|
$this->assertFalse(empty($records[2]));
|
|
$this->assertEqual(3, $records[1]);
|
|
$this->assertEqual(3, $records[2]);
|
|
|
|
}
|
|
|
|
public function test_get_records_select_menu() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 2));
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 5));
|
|
|
|
$this->assertTrue($records = $DB->get_records_select_menu($tablename, "course > ?", array(2)));
|
|
|
|
$this->assertEqual(3, count($records));
|
|
$this->assertFalse(empty($records[1]));
|
|
$this->assertTrue(empty($records[2]));
|
|
$this->assertFalse(empty($records[3]));
|
|
$this->assertFalse(empty($records[4]));
|
|
$this->assertEqual(3, $records[1]);
|
|
$this->assertEqual(3, $records[3]);
|
|
$this->assertEqual(5, $records[4]);
|
|
|
|
}
|
|
|
|
public function test_get_records_sql_menu() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 2));
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 5));
|
|
|
|
$this->assertTrue($records = $DB->get_records_sql_menu("SELECT * FROM {".$tablename."} WHERE course > ?", array(2)));
|
|
|
|
$this->assertEqual(3, count($records));
|
|
$this->assertFalse(empty($records[1]));
|
|
$this->assertTrue(empty($records[2]));
|
|
$this->assertFalse(empty($records[3]));
|
|
$this->assertFalse(empty($records[4]));
|
|
$this->assertEqual(3, $records[1]);
|
|
$this->assertEqual(3, $records[3]);
|
|
$this->assertEqual(5, $records[4]);
|
|
|
|
}
|
|
|
|
public function test_get_record() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 2));
|
|
|
|
$this->assertTrue($record = $DB->get_record($tablename, array('id' => 2)));
|
|
|
|
$this->assertEqual(2, $record->course);
|
|
}
|
|
|
|
public function test_get_record_select() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 2));
|
|
|
|
$this->assertTrue($record = $DB->get_record_select($tablename, "id = ?", array(2)));
|
|
|
|
$this->assertEqual(2, $record->course);
|
|
|
|
}
|
|
|
|
public function test_get_record_sql() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 2));
|
|
|
|
$this->assertTrue($record = $DB->get_record_sql("SELECT * FROM {".$tablename."} WHERE id = ?", array(2)));
|
|
|
|
$this->assertEqual(2, $record->course);
|
|
|
|
}
|
|
|
|
public function test_get_field() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
|
|
$this->assertTrue($course = $DB->get_field($tablename, 'course', array('id' => 1)));
|
|
$this->assertEqual(3, $course);
|
|
}
|
|
|
|
public function test_get_field_select() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
|
|
$this->assertTrue($course = $DB->get_field_select($tablename, 'course', "id = ?", array(1)));
|
|
$this->assertEqual(3, $course);
|
|
|
|
}
|
|
|
|
public function test_get_field_sql() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
|
|
$this->assertTrue($course = $DB->get_field_sql("SELECT course FROM {".$tablename."} WHERE id = ?", array(1)));
|
|
$this->assertEqual(3, $course);
|
|
|
|
}
|
|
|
|
public function test_get_fieldset_select() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('course' => 1));
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 2));
|
|
$DB->insert_record($tablename, array('course' => 6));
|
|
|
|
$this->assertTrue($fieldset = $DB->get_fieldset_select($tablename, 'course', "course > ?", array(1)));
|
|
|
|
$this->assertEqual(3, count($fieldset));
|
|
$this->assertEqual(3, $fieldset[0]);
|
|
$this->assertEqual(2, $fieldset[1]);
|
|
$this->assertEqual(6, $fieldset[2]);
|
|
|
|
}
|
|
|
|
public function test_get_fieldset_sql() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('course' => 1));
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 2));
|
|
$DB->insert_record($tablename, array('course' => 6));
|
|
|
|
$this->assertTrue($fieldset = $DB->get_fieldset_sql("SELECT * FROM {".$tablename."} WHERE course > ?", array(1)));
|
|
|
|
$this->assertEqual(3, count($fieldset));
|
|
$this->assertEqual(2, $fieldset[0]);
|
|
$this->assertEqual(3, $fieldset[1]);
|
|
$this->assertEqual(4, $fieldset[2]);
|
|
}
|
|
|
|
public function test_insert_record_raw() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$this->assertTrue($DB->insert_record_raw($tablename, array('course' => 1)));
|
|
$this->assertTrue($record = $DB->get_record($tablename, array('course' => 1)));
|
|
$this->assertEqual(1, $record->course);
|
|
}
|
|
|
|
public function test_insert_record() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$this->assertTrue($DB->insert_record($tablename, array('course' => 1)));
|
|
$this->assertTrue($record = $DB->get_record($tablename, array('course' => 1)));
|
|
$this->assertEqual(1, $record->course);
|
|
|
|
}
|
|
|
|
public function test_import_record() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$record = (object)array('id'=>666, 'course'=>10);
|
|
$this->assertTrue($DB->import_record($tablename, $record));
|
|
$records = $DB->get_records($tablename);
|
|
$this->assertEqual(1, count($records));
|
|
$this->assertEqual(10, $records[666]->course);
|
|
|
|
$record = (object)array('id'=>13, 'course'=>2);
|
|
$this->assertTrue($DB->import_record($tablename, $record));
|
|
$records = $DB->get_records($tablename);
|
|
$this->assertEqual(2, $records[13]->course);
|
|
}
|
|
|
|
public function test_insert_record_clob() {
|
|
global $CFG;
|
|
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('description', XMLDB_TYPE_TEXT, 'big', null, null, null, null);
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$clob = file_get_contents($CFG->libdir.'/dml/simpletest/fixtures/clob.txt');
|
|
|
|
$id = $DB->insert_record($tablename, array('description' => $clob));
|
|
$this->assertEqual($id, 1);
|
|
$record = $DB->get_record($tablename, array('id' => $id));
|
|
$this->assertEqual($clob, $record->description);
|
|
|
|
}
|
|
|
|
public function test_insert_record_multiple_lobs() {
|
|
global $CFG;
|
|
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('description', XMLDB_TYPE_TEXT, 'big', null, null, null, null);
|
|
$table->add_field('image', XMLDB_TYPE_BINARY, 'big', null, null, null, null);
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$clob = file_get_contents($CFG->libdir.'/dml/simpletest/fixtures/clob.txt');
|
|
$blob = file_get_contents($CFG->libdir.'/dml/simpletest/fixtures/randombinary');
|
|
|
|
$this->assertTrue($id = $DB->insert_record($tablename, array('description' => $clob, 'image' => $blob)));
|
|
$record = $DB->get_record($tablename, array('id' => $id));
|
|
$this->assertEqual($clob, $record->description);
|
|
$this->assertEqual($blob, $record->image);
|
|
$this->assertEqual($clob, $DB->get_field($tablename, 'description', array('id' => $id)));
|
|
$this->assertEqual($blob, $DB->get_field($tablename, 'image', array('id' => $id)));
|
|
|
|
}
|
|
|
|
|
|
public function test_update_record_raw() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('course' => 1));
|
|
$record = $DB->get_record($tablename, array('course' => 1));
|
|
$record->course = 2;
|
|
$this->assertTrue($DB->update_record_raw($tablename, $record));
|
|
$this->assertFalse($record = $DB->get_record($tablename, array('course' => 1)));
|
|
$this->assertTrue($record = $DB->get_record($tablename, array('course' => 2)));
|
|
}
|
|
|
|
public function test_update_record() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('course' => 1));
|
|
$record = $DB->get_record($tablename, array('course' => 1));
|
|
$record->course = 2;
|
|
$this->assertTrue($DB->update_record($tablename, $record));
|
|
$this->assertFalse($record = $DB->get_record($tablename, array('course' => 1)));
|
|
$this->assertTrue($record = $DB->get_record($tablename, array('course' => 2)));
|
|
}
|
|
|
|
public function test_update_record_clob() {
|
|
global $CFG;
|
|
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('description', XMLDB_TYPE_TEXT, 'big', null, null, null, null);
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$clob = file_get_contents($CFG->libdir.'/dml/simpletest/fixtures/clob.txt');
|
|
|
|
$id = $DB->insert_record($tablename, array('description' => $clob));
|
|
$record = $DB->get_record($tablename, array('id' => $id));
|
|
$record->description = substr($clob, 0, 500);
|
|
$this->assertTrue($DB->update_record($tablename, $record));
|
|
|
|
$record = $DB->get_record($tablename, array('id' => $id));
|
|
$this->assertEqual(substr($clob, 0, 500), $record->description);
|
|
}
|
|
|
|
public function test_update_record_multiple_lobs() {
|
|
global $CFG;
|
|
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('description', XMLDB_TYPE_TEXT, 'big', null, null, null, null);
|
|
$table->add_field('image', XMLDB_TYPE_BINARY, 'big', null, null, null, null);
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$clob = file_get_contents($CFG->libdir.'/dml/simpletest/fixtures/clob.txt');
|
|
$blob = file_get_contents($CFG->libdir.'/dml/simpletest/fixtures/randombinary');
|
|
|
|
$newclob = substr($clob, 0, 500);
|
|
$newblob = substr($blob, 0, 250);
|
|
|
|
$id = $DB->insert_record($tablename, array('description' => $clob, 'image' => $blob));
|
|
$record = $DB->get_record($tablename, array('id' => $id));
|
|
$record->description = $newclob;
|
|
$record->image = $newblob;
|
|
$this->assertTrue($DB->update_record($tablename, $record));
|
|
|
|
$record = $DB->get_record($tablename, array('id' => $id));
|
|
$this->assertEqual($newclob, $record->description);
|
|
$this->assertEqual($newblob, $record->image);
|
|
$this->assertEqual($newclob, $DB->get_field($tablename, 'description', array('id' => $id)));
|
|
$this->assertEqual($newblob, $DB->get_field($tablename, 'image', array('id' => $id)));
|
|
|
|
}
|
|
|
|
public function test_set_field() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('course' => 1));
|
|
|
|
$this->assertTrue($DB->set_field($tablename, 'course', 2, array('id' => 1)));
|
|
$this->assertEqual(2, $DB->get_field($tablename, 'course', array('id' => 1)));
|
|
}
|
|
|
|
public function test_set_field_select() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('course' => 1));
|
|
|
|
$this->assertTrue($DB->set_field_select($tablename, 'course', 2, 'id = ?', array(1)));
|
|
$this->assertEqual(2, $DB->get_field($tablename, 'course', array('id' => 1)));
|
|
|
|
}
|
|
|
|
public function test_count_records() {
|
|
$DB = $this->tdb;
|
|
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$this->assertEqual(0, $DB->count_records($tablename));
|
|
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 4));
|
|
$DB->insert_record($tablename, array('course' => 5));
|
|
|
|
$this->assertEqual(3, $DB->count_records($tablename));
|
|
}
|
|
|
|
public function test_count_records_select() {
|
|
$DB = $this->tdb;
|
|
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$this->assertEqual(0, $DB->count_records($tablename));
|
|
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 4));
|
|
$DB->insert_record($tablename, array('course' => 5));
|
|
|
|
$this->assertEqual(2, $DB->count_records_select($tablename, 'course > ?', array(3)));
|
|
}
|
|
|
|
public function test_count_records_sql() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$this->assertEqual(0, $DB->count_records($tablename));
|
|
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 4));
|
|
$DB->insert_record($tablename, array('course' => 5));
|
|
|
|
$this->assertEqual(2, $DB->count_records_sql("SELECT COUNT(*) FROM {".$tablename."} WHERE course > ?", array(3)));
|
|
}
|
|
|
|
public function test_record_exists() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$this->assertEqual(0, $DB->count_records($tablename));
|
|
|
|
$this->assertFalse($DB->record_exists($tablename, array('course' => 3)));
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
|
|
$this->assertTrue($DB->record_exists($tablename, array('course' => 3)));
|
|
|
|
}
|
|
|
|
public function test_record_exists_select() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$this->assertEqual(0, $DB->count_records($tablename));
|
|
|
|
$this->assertFalse($DB->record_exists_select($tablename, "course = ?", array(3)));
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
|
|
$this->assertTrue($DB->record_exists_select($tablename, "course = ?", array(3)));
|
|
}
|
|
|
|
public function test_record_exists_sql() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$this->assertEqual(0, $DB->count_records($tablename));
|
|
|
|
$this->assertFalse($DB->record_exists_sql("SELECT * FROM {".$tablename."} WHERE course = ?", array(3)));
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
|
|
$this->assertTrue($DB->record_exists_sql("SELECT * FROM {".$tablename."} WHERE course = ?", array(3)));
|
|
}
|
|
|
|
public function test_delete_records() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 2));
|
|
$DB->insert_record($tablename, array('course' => 2));
|
|
|
|
// Delete all records
|
|
$this->assertTrue($DB->delete_records($tablename));
|
|
$this->assertEqual(0, $DB->count_records($tablename));
|
|
|
|
// Delete subset of records
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 2));
|
|
$DB->insert_record($tablename, array('course' => 2));
|
|
|
|
$this->assertTrue($DB->delete_records($tablename, array('course' => 2)));
|
|
$this->assertEqual(1, $DB->count_records($tablename));
|
|
}
|
|
|
|
public function test_delete_records_select() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
$DB->insert_record($tablename, array('course' => 2));
|
|
$DB->insert_record($tablename, array('course' => 2));
|
|
|
|
$this->assertTrue($DB->delete_records_select($tablename, 'course = ?', array(2)));
|
|
$this->assertEqual(1, $DB->count_records($tablename));
|
|
}
|
|
|
|
public function test_delete_records_list() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('course' => 1));
|
|
$DB->insert_record($tablename, array('course' => 2));
|
|
$DB->insert_record($tablename, array('course' => 3));
|
|
|
|
$this->assertTrue($DB->delete_records_list($tablename, 'course', array(2, 3)));
|
|
$this->assertEqual(1, $DB->count_records($tablename));
|
|
|
|
$this->assertTrue($DB->delete_records_list($tablename, 'course', array())); /// Must delete 0 rows without conditions. MDL-17645
|
|
$this->assertEqual(1, $DB->count_records($tablename));
|
|
}
|
|
|
|
function test_sql_null_from_clause() {
|
|
$DB = $this->tdb;
|
|
$sql = "SELECT 1 AS id ".$DB->sql_null_from_clause();
|
|
$this->assertEqual($DB->get_field_sql($sql), 1);
|
|
}
|
|
|
|
function test_sql_bitand() {
|
|
$DB = $this->tdb;
|
|
$sql = "SELECT ".$DB->sql_bitand(10, 3)." AS res ".$DB->sql_null_from_clause();
|
|
$this->assertEqual($DB->get_field_sql($sql), 2);
|
|
}
|
|
|
|
function test_sql_bitnot() {
|
|
$DB = $this->tdb;
|
|
|
|
$not = $DB->sql_bitnot(2);
|
|
$notlimited = $DB->sql_bitand($not, 7); // might be positive or negative number which can not fit into PHP INT!
|
|
|
|
$sql = "SELECT $notlimited AS res ".$DB->sql_null_from_clause();
|
|
$this->assertEqual($DB->get_field_sql($sql), 5);
|
|
}
|
|
|
|
function test_sql_bitor() {
|
|
$DB = $this->tdb;
|
|
$sql = "SELECT ".$DB->sql_bitor(10, 3)." AS res ".$DB->sql_null_from_clause();
|
|
$this->assertEqual($DB->get_field_sql($sql), 11);
|
|
}
|
|
|
|
function test_sql_bitxor() {
|
|
$DB = $this->tdb;
|
|
$sql = "SELECT ".$DB->sql_bitxor(10, 3)." AS res ".$DB->sql_null_from_clause();
|
|
$this->assertEqual($DB->get_field_sql($sql), 9);
|
|
}
|
|
|
|
function test_sql_modulo() {
|
|
$DB = $this->tdb;
|
|
$sql = "SELECT ".$DB->sql_modulo(10, 7)." AS res ".$DB->sql_null_from_clause();
|
|
$this->assertEqual($DB->get_field_sql($sql), 3);
|
|
}
|
|
|
|
function test_sql_ceil() {
|
|
$DB = $this->tdb;
|
|
$sql = "SELECT ".$DB->sql_ceil(665.666)." AS res ".$DB->sql_null_from_clause();
|
|
$this->assertEqual($DB->get_field_sql($sql), 666);
|
|
}
|
|
|
|
function test_cast_char2int() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table1 = $this->get_test_table("testtable1");
|
|
$tablename1 = $table1->getName();
|
|
|
|
$table1->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table1->add_field('name', XMLDB_TYPE_CHAR, '255', null, null, null, null);
|
|
$table1->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table1);
|
|
$this->tables[$tablename1] = $table1;
|
|
|
|
$DB->insert_record($tablename1, array('name'=>'100'));
|
|
|
|
$table2 = $this->get_test_table("testtable2");
|
|
$tablename2 = $table2->getName();
|
|
$table2->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table2->add_field('res', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table2->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table2);
|
|
$this->tables[$table2->getName()] = $table2;
|
|
|
|
$DB->insert_record($tablename2, array('res'=>100));
|
|
|
|
try {
|
|
$sql = "SELECT * FROM {".$tablename1."} t1, {".$tablename2."} t2 WHERE ".$DB->sql_cast_char2int("t1.name")." = t2.res ";
|
|
$records = $DB->get_records_sql($sql);
|
|
$this->assertEqual(count($records), 1);
|
|
} catch (dml_exception $e) {
|
|
$this->fail("No exception expected");
|
|
}
|
|
}
|
|
|
|
function test_cast_char2real() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('name', XMLDB_TYPE_CHAR, '255', null, null, null, null);
|
|
$table->add_field('res', XMLDB_TYPE_NUMBER, '12, 7', null, null, null, null);
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('name'=>'10.10', 'res'=>5.1));
|
|
$DB->insert_record($tablename, array('name'=>'1.10', 'res'=>666));
|
|
$DB->insert_record($tablename, array('name'=>'11.10', 'res'=>0.1));
|
|
|
|
$sql = "SELECT * FROM {".$tablename."} WHERE ".$DB->sql_cast_char2real('name')." > res";
|
|
$records = $DB->get_records_sql($sql);
|
|
$this->assertEqual(count($records), 2);
|
|
}
|
|
|
|
function sql_compare_text() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('name', XMLDB_TYPE_CHAR, '255', null, null, null, null);
|
|
$table->add_field('description', XMLDB_TYPE_TEXT, 'big', null, null, null, null);
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('name'=>'abcd', 'description'=>'abcd'));
|
|
$DB->insert_record($tablename, array('name'=>'abcdef', 'description'=>'bbcdef'));
|
|
$DB->insert_record($tablename, array('name'=>'aaaabb', 'description'=>'aaaacccccccccccccccccc'));
|
|
|
|
$sql = "SELECT * FROM {".$tablename."} WHERE name = ".$DB->sql_compare_text('description');
|
|
$records = $DB->get_records_sql($sql);
|
|
$this->assertEqual(count($records), 1);
|
|
|
|
$sql = "SELECT * FROM {".$tablename."} WHERE name = ".$DB->sql_compare_text('description', 4);
|
|
$records = $DB->get_records_sql($sql);
|
|
$this->assertEqual(count($records), 2);
|
|
}
|
|
|
|
function test_ilike() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('name', XMLDB_TYPE_CHAR, '255', null, null, null, null);
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('name'=>'SuperDuperRecord'));
|
|
$DB->insert_record($tablename, array('name'=>'NoDupor'));
|
|
$DB->insert_record($tablename, array('name'=>'ouch'));
|
|
|
|
$sql = "SELECT * FROM {".$tablename."} WHERE name ".$DB->sql_ilike()." ?";
|
|
$params = array("%dup_r%");
|
|
$records = $DB->get_records_sql($sql, $params);
|
|
$this->assertEqual(count($records), 2);
|
|
}
|
|
|
|
function test_concat() {
|
|
$DB = $this->tdb;
|
|
$sql = "SELECT ".$DB->sql_concat("?", "?", "?")." AS fullname ".$DB->sql_null_from_clause();
|
|
$params = array("name", "name2", "name3");
|
|
$this->assertEqual("namename2name3", $DB->get_field_sql($sql, $params));
|
|
}
|
|
|
|
function test_concat_join() {
|
|
$DB = $this->tdb;
|
|
$sql = "SELECT ".$DB->sql_concat_join("' '", array("?", "?", "?"))." AS fullname ".$DB->sql_null_from_clause();
|
|
$params = array("name", "name2", "name3");
|
|
$result = $DB->get_field_sql($sql, $params);
|
|
$this->assertEqual("name name2 name3", $result);
|
|
}
|
|
|
|
function test_sql_fullname() {
|
|
$DB = $this->tdb;
|
|
$sql = "SELECT ".$DB->sql_fullname(':first', ':last')." AS fullname ".$DB->sql_null_from_clause();
|
|
$params = array('first'=>'Firstname', 'last'=>'Surname');
|
|
$this->assertEqual("Firstname Surname", $DB->get_field_sql($sql, $params));
|
|
}
|
|
|
|
function sql_sql_order_by_text() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('description', XMLDB_TYPE_TEXT, 'big', null, null, null, null);
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('description'=>'abcd'));
|
|
$DB->insert_record($tablename, array('description'=>'dxxx'));
|
|
$DB->insert_record($tablename, array('description'=>'bcde'));
|
|
|
|
$sql = "SELECT * FROM {".$tablename."} ORDER BY ".$DB->sql_order_by_text('description');
|
|
$records = $DB->get_records_sql($sql);
|
|
$first = array_unshift($records);
|
|
$this->assertEqual(1, $first->id);
|
|
$second = array_unshift($records);
|
|
$this->assertEqual(3, $second->id);
|
|
$last = array_unshift($records);
|
|
$this->assertEqual(2, $last->id);
|
|
}
|
|
|
|
function test_sql_substring() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('name', XMLDB_TYPE_CHAR, '255', null, null, null, null);
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$string = 'abcdefghij';
|
|
|
|
$DB->insert_record($tablename, array('name'=>$string));
|
|
|
|
$sql = "SELECT id, ".$DB->sql_substr("name", 5)." AS name FROM {".$tablename."}";
|
|
$record = $DB->get_record_sql($sql);
|
|
$this->assertEqual(substr($string, 5-1), $record->name);
|
|
|
|
$sql = "SELECT id, ".$DB->sql_substr("name", 5, 2)." AS name FROM {".$tablename."}";
|
|
$record = $DB->get_record_sql($sql);
|
|
$this->assertEqual(substr($string, 5-1, 2), $record->name);
|
|
|
|
try {
|
|
// silence php warning ;-)
|
|
@$DB->sql_substr("name");
|
|
$this->fail("Expecting an exception, none occurred");
|
|
} catch (Exception $e) {
|
|
$this->assertTrue($e instanceof coding_exception);
|
|
}
|
|
}
|
|
|
|
function test_sql_length() {
|
|
$DB = $this->tdb;
|
|
$this->assertEqual($DB->get_field_sql(
|
|
"SELECT ".$DB->sql_length("'aeiou'").$DB->sql_null_from_clause()), 5);
|
|
$this->assertEqual($DB->get_field_sql(
|
|
"SELECT ".$DB->sql_length("'áéíóú'").$DB->sql_null_from_clause()), 5);
|
|
}
|
|
|
|
function test_sql_position() {
|
|
$DB = $this->tdb;
|
|
$this->assertEqual($DB->get_field_sql(
|
|
"SELECT ".$DB->sql_position("'ood'", "'Moodle'").$DB->sql_null_from_clause()), 2);
|
|
$this->assertEqual($DB->get_field_sql(
|
|
"SELECT ".$DB->sql_position("'Oracle'", "'Moodle'").$DB->sql_null_from_clause()), 0);
|
|
}
|
|
|
|
function test_sql_empty() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('name', XMLDB_TYPE_CHAR, '255', null, null, null, null);
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('name'=>''));
|
|
$DB->insert_record($tablename, array('name'=>null));
|
|
$DB->insert_record($tablename, array('name'=>'lalalal'));
|
|
$DB->insert_record($tablename, array('name'=>0));
|
|
|
|
$records = $DB->get_records_sql("SELECT * FROM {".$tablename."} WHERE name = '".$DB->sql_empty()."'");
|
|
$this->assertEqual(count($records), 1);
|
|
$record = reset($records);
|
|
$this->assertEqual($record->name, '');
|
|
}
|
|
|
|
function test_sql_isempty() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('name', XMLDB_TYPE_CHAR, '255', null, XMLDB_NOTNULL, null, null);
|
|
$table->add_field('namenull', XMLDB_TYPE_CHAR, '255', null, null, null, null);
|
|
$table->add_field('description', XMLDB_TYPE_TEXT, 'big', null, XMLDB_NOTNULL, null, null);
|
|
$table->add_field('descriptionnull', XMLDB_TYPE_TEXT, 'big', null, null, null, null);
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('name'=>'', 'namenull'=>'', 'description'=>'', 'descriptionnull'=>''));
|
|
$DB->insert_record($tablename, array('name'=>'??', 'namenull'=>null, 'description'=>'??', 'descriptionnull'=>null));
|
|
$DB->insert_record($tablename, array('name'=>'la', 'namenull'=>'la', 'description'=>'la', 'descriptionnull'=>'lalala'));
|
|
$DB->insert_record($tablename, array('name'=>0, 'namenull'=>0, 'description'=>0, 'descriptionnull'=>0));
|
|
|
|
$records = $DB->get_records_sql("SELECT * FROM {".$tablename."} WHERE ".$DB->sql_isempty($tablename, 'name', false, false));
|
|
$this->assertEqual(count($records), 1);
|
|
$record = reset($records);
|
|
$this->assertEqual($record->name, '');
|
|
|
|
$records = $DB->get_records_sql("SELECT * FROM {".$tablename."} WHERE ".$DB->sql_isempty($tablename, 'namenull', true, false));
|
|
$this->assertEqual(count($records), 1);
|
|
$record = reset($records);
|
|
$this->assertEqual($record->namenull, '');
|
|
|
|
$records = $DB->get_records_sql("SELECT * FROM {".$tablename."} WHERE ".$DB->sql_isempty($tablename, 'description', false, true));
|
|
$this->assertEqual(count($records), 1);
|
|
$record = reset($records);
|
|
$this->assertEqual($record->description, '');
|
|
|
|
$records = $DB->get_records_sql("SELECT * FROM {".$tablename."} WHERE ".$DB->sql_isempty($tablename, 'descriptionnull', true, true));
|
|
$this->assertEqual(count($records), 1);
|
|
$record = reset($records);
|
|
$this->assertEqual($record->descriptionnull, '');
|
|
}
|
|
|
|
function sql_isnotempty() {
|
|
//TODO
|
|
}
|
|
|
|
function test_sql_regex() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
if (!$DB->sql_regex_supported()) {
|
|
return;
|
|
}
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('name', XMLDB_TYPE_CHAR, '255', null, null, null, null);
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$DB->insert_record($tablename, array('name'=>'lalala'));
|
|
$DB->insert_record($tablename, array('name'=>'holaaa'));
|
|
$DB->insert_record($tablename, array('name'=>'aouch'));
|
|
|
|
$sql = "SELECT * FROM {".$tablename."} WHERE name ".$DB->sql_regex()." ?";
|
|
$params = array('a$');
|
|
$records = $DB->get_records_sql($sql, $params);
|
|
$this->assertEqual(count($records), 2);
|
|
|
|
$sql = "SELECT * FROM {".$tablename."} WHERE name ".$DB->sql_regex(false)." ?";
|
|
$params = array('.a');
|
|
$records = $DB->get_records_sql($sql, $params);
|
|
$this->assertEqual(count($records), 1);
|
|
|
|
}
|
|
|
|
function test_begin_sql() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$active = $DB->begin_sql();
|
|
if ($active) {
|
|
// test only if driver supports transactions
|
|
$data = (object)array('course'=>3);
|
|
$DB->insert_record($tablename, $data);
|
|
$this->assertEqual(1, $DB->count_records($tablename));
|
|
$DB->commit_sql();
|
|
}
|
|
}
|
|
|
|
function test_commit_sql() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$active = $DB->begin_sql();
|
|
if ($active) {
|
|
// test only if driver supports transactions
|
|
$data = (object)array('course'=>3);
|
|
$DB->insert_record($tablename, $data);
|
|
$DB->commit_sql();
|
|
$this->assertEqual(1, $DB->count_records($tablename));
|
|
}
|
|
}
|
|
|
|
function test_rollback_sql() {
|
|
$DB = $this->tdb;
|
|
$dbman = $DB->get_manager();
|
|
|
|
$table = $this->get_test_table();
|
|
$tablename = $table->getName();
|
|
|
|
$table->add_field('id', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, XMLDB_SEQUENCE, null);
|
|
$table->add_field('course', XMLDB_TYPE_INTEGER, '10', XMLDB_UNSIGNED, XMLDB_NOTNULL, null, '0');
|
|
$table->add_key('primary', XMLDB_KEY_PRIMARY, array('id'));
|
|
$dbman->create_table($table);
|
|
$this->tables[$tablename] = $table;
|
|
|
|
$active = $DB->begin_sql();
|
|
if ($active) {
|
|
// test only if driver supports transactions
|
|
$data = (object)array('course'=>3);
|
|
$DB->insert_record($tablename, $data);
|
|
$DB->rollback_sql();
|
|
$this->assertEqual(0, $DB->count_records($tablename));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This class is not a proper subclass of moodle_database. It is
|
|
* intended to be used only in unit tests, in order to gain access to the
|
|
* protected methods of moodle_database, and unit test them.
|
|
*/
|
|
class moodle_database_for_testing extends moodle_database {
|
|
protected $prefix = 'mdl_';
|
|
|
|
public function public_fix_table_names($sql) {
|
|
return $this->fix_table_names($sql);
|
|
}
|
|
|
|
public function driver_installed(){}
|
|
public function get_dbfamily(){}
|
|
protected function get_dbtype(){}
|
|
protected function get_dblibrary(){}
|
|
public function get_name(){}
|
|
public function get_configuration_help(){}
|
|
public function get_configuration_hints(){}
|
|
public function connect($dbhost, $dbuser, $dbpass, $dbname, $prefix, array $dboptions=null){}
|
|
public function get_server_info(){}
|
|
protected function allowed_param_types(){}
|
|
public function get_last_error(){}
|
|
public function get_tables($usecache=true){}
|
|
public function get_indexes($table){}
|
|
public function get_columns($table, $usecache=true){}
|
|
public function set_debug($state){}
|
|
public function get_debug(){}
|
|
public function set_logging($state){}
|
|
public function change_database_structure($sql){}
|
|
public function execute($sql, array $params=null){}
|
|
public function get_recordset_sql($sql, array $params=null, $limitfrom=0, $limitnum=0){}
|
|
public function get_records_sql($sql, array $params=null, $limitfrom=0, $limitnum=0){}
|
|
public function get_fieldset_sql($sql, array $params=null){}
|
|
public function insert_record_raw($table, $params, $returnid=true, $bulk=false, $customsequence=false){}
|
|
public function insert_record($table, $dataobject, $returnid=true, $bulk=false){}
|
|
public function import_record($table, $dataobject){}
|
|
public function update_record_raw($table, $params, $bulk=false){}
|
|
public function update_record($table, $dataobject, $bulk=false){}
|
|
public function set_field_select($table, $newfield, $newvalue, $select, array $params=null){}
|
|
public function delete_records_select($table, $select, array $params=null){}
|
|
public function sql_concat(){}
|
|
public function sql_concat_join($separator="' '", $elements=array()){}
|
|
public function sql_substr($expr, $start, $length=false){}
|
|
}
|