You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
558 lines
18 KiB
558 lines
18 KiB
<?php
|
|
// This file is part of Moodle - http://moodle.org/
|
|
//
|
|
// Moodle is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// Moodle is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
/**
|
|
* This class represent one XMLDB structure
|
|
*
|
|
* @package core_xmldb
|
|
* @copyright 1999 onwards Martin Dougiamas http://dougiamas.com
|
|
* 2001-3001 Eloy Lafuente (stronk7) http://contiento.com
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
defined('MOODLE_INTERNAL') || die();
|
|
|
|
|
|
class xmldb_structure extends xmldb_object {
|
|
|
|
/** @var string */
|
|
protected $path;
|
|
|
|
/** @var string */
|
|
protected $version;
|
|
|
|
/** @var array tables */
|
|
protected $tables;
|
|
|
|
/**
|
|
* Creates one new xmldb_structure
|
|
* @param string $name
|
|
*/
|
|
public function __construct($name) {
|
|
parent::__construct($name);
|
|
$this->path = null;
|
|
$this->version = null;
|
|
$this->tables = array();
|
|
}
|
|
|
|
/**
|
|
* Returns the path of the structure
|
|
* @return string
|
|
*/
|
|
public function getPath() {
|
|
return $this->path;
|
|
}
|
|
|
|
/**
|
|
* Returns the version of the structure
|
|
* @return string
|
|
*/
|
|
public function getVersion() {
|
|
return $this->version;
|
|
}
|
|
|
|
/**
|
|
* Returns one xmldb_table
|
|
* @param string $tablename
|
|
* @return xmldb_table
|
|
*/
|
|
public function getTable($tablename) {
|
|
$i = $this->findTableInArray($tablename);
|
|
if ($i !== null) {
|
|
return $this->tables[$i];
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Returns the position of one table in the array.
|
|
* @param string $tablename
|
|
* @return mixed
|
|
*/
|
|
public function findTableInArray($tablename) {
|
|
foreach ($this->tables as $i => $table) {
|
|
if ($tablename == $table->getName()) {
|
|
return $i;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* This function will reorder the array of tables
|
|
* @return bool success
|
|
*/
|
|
public function orderTables() {
|
|
$result = $this->orderElements($this->tables);
|
|
if ($result) {
|
|
$this->setTables($result);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the tables of the structure
|
|
* @return array
|
|
*/
|
|
public function getTables() {
|
|
return $this->tables;
|
|
}
|
|
|
|
/**
|
|
* Set the structure version
|
|
* @param string version
|
|
*/
|
|
public function setVersion($version) {
|
|
$this->version = $version;
|
|
}
|
|
|
|
/**
|
|
* Add one table to the structure, allowing to specify the desired order
|
|
* If it's not specified, then the table is added at the end.
|
|
* @param xmldb_table $table
|
|
* @param mixed $after
|
|
*/
|
|
public function addTable($table, $after=null) {
|
|
|
|
// Calculate the previous and next tables
|
|
$prevtable = null;
|
|
$nexttable = null;
|
|
|
|
if (!$after) {
|
|
if ($this->tables) {
|
|
end($this->tables);
|
|
$prevtable = $this->tables[key($this->tables)];
|
|
}
|
|
} else {
|
|
$prevtable = $this->getTable($after);
|
|
}
|
|
if ($prevtable && $prevtable->getNext()) {
|
|
$nexttable = $this->getTable($prevtable->getNext());
|
|
}
|
|
|
|
// Set current table previous and next attributes
|
|
if ($prevtable) {
|
|
$table->setPrevious($prevtable->getName());
|
|
$prevtable->setNext($table->getName());
|
|
}
|
|
if ($nexttable) {
|
|
$table->setNext($nexttable->getName());
|
|
$nexttable->setPrevious($table->getName());
|
|
}
|
|
// Some more attributes
|
|
$table->setLoaded(true);
|
|
$table->setChanged(true);
|
|
// Add the new table
|
|
$this->tables[] = $table;
|
|
// Reorder the whole structure
|
|
$this->orderTables($this->tables);
|
|
// Recalculate the hash
|
|
$this->calculateHash(true);
|
|
// We have one new table, so the structure has changed
|
|
$this->setVersion(userdate(time(), '%Y%m%d', 99, false));
|
|
$this->setChanged(true);
|
|
}
|
|
|
|
/**
|
|
* Delete one table from the Structure
|
|
* @param string $tablename
|
|
*/
|
|
public function deleteTable($tablename) {
|
|
|
|
$table = $this->getTable($tablename);
|
|
if ($table) {
|
|
$i = $this->findTableInArray($tablename);
|
|
// Look for prev and next table
|
|
$prevtable = $this->getTable($table->getPrevious());
|
|
$nexttable = $this->getTable($table->getNext());
|
|
// Change their previous and next attributes
|
|
if ($prevtable) {
|
|
$prevtable->setNext($table->getNext());
|
|
}
|
|
if ($nexttable) {
|
|
$nexttable->setPrevious($table->getPrevious());
|
|
}
|
|
// Delete the table
|
|
unset($this->tables[$i]);
|
|
// Reorder the tables
|
|
$this->orderTables($this->tables);
|
|
// Recalculate the hash
|
|
$this->calculateHash(true);
|
|
// We have one deleted table, so the structure has changed
|
|
$this->setVersion(userdate(time(), '%Y%m%d', 99, false));
|
|
$this->setChanged(true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set the tables
|
|
* @param array $tables
|
|
*/
|
|
public function setTables($tables) {
|
|
$this->tables = $tables;
|
|
}
|
|
|
|
/**
|
|
* Load data from XML to the structure
|
|
* @param array $xmlarr
|
|
* @return bool
|
|
*/
|
|
public function arr2xmldb_structure($xmlarr) {
|
|
|
|
global $CFG;
|
|
|
|
$result = true;
|
|
|
|
// Debug the structure
|
|
// traverse_xmlize($xmlarr); //Debug
|
|
// print_object ($GLOBALS['traverse_array']); //Debug
|
|
// $GLOBALS['traverse_array']=""; //Debug
|
|
|
|
// Process structure attributes (path, comment and version)
|
|
if (isset($xmlarr['XMLDB']['@']['PATH'])) {
|
|
$this->path = trim($xmlarr['XMLDB']['@']['PATH']);
|
|
} else {
|
|
$this->errormsg = 'Missing PATH attribute';
|
|
$this->debug($this->errormsg);
|
|
$result = false;
|
|
}
|
|
// Normalize paths to compare them.
|
|
$filepath = realpath($this->name); // File path comes in name.
|
|
$filename = basename($filepath);
|
|
$normalisedpath = $this->path;
|
|
if ($CFG->admin !== 'admin') {
|
|
$needle = 'admin/';
|
|
if (strpos($this->path, $needle) === 0) {
|
|
$normalisedpath = substr_replace($this->path, "$CFG->admin/", 0, strlen($needle));
|
|
}
|
|
}
|
|
$structurepath = realpath($CFG->dirroot . DIRECTORY_SEPARATOR . $normalisedpath . DIRECTORY_SEPARATOR . $filename);
|
|
if ($filepath !== $structurepath) {
|
|
$relativepath = dirname(str_replace(realpath($CFG->dirroot) . DIRECTORY_SEPARATOR, '', $filepath));
|
|
$this->errormsg = 'PATH attribute does not match file directory: ' . $relativepath;
|
|
$this->debug($this->errormsg);
|
|
$result = false;
|
|
}
|
|
if (isset($xmlarr['XMLDB']['@']['VERSION'])) {
|
|
$this->version = trim($xmlarr['XMLDB']['@']['VERSION']);
|
|
} else {
|
|
$this->errormsg = 'Missing VERSION attribute';
|
|
$this->debug($this->errormsg);
|
|
$result = false;
|
|
}
|
|
if (isset($xmlarr['XMLDB']['@']['COMMENT'])) {
|
|
$this->comment = trim($xmlarr['XMLDB']['@']['COMMENT']);
|
|
} else if (!empty($CFG->xmldbdisablecommentchecking)) {
|
|
$this->comment = '';
|
|
} else {
|
|
$this->errormsg = 'Missing COMMENT attribute';
|
|
$this->debug($this->errormsg);
|
|
$result = false;
|
|
}
|
|
|
|
// Iterate over tables
|
|
if (isset($xmlarr['XMLDB']['#']['TABLES']['0']['#']['TABLE'])) {
|
|
foreach ($xmlarr['XMLDB']['#']['TABLES']['0']['#']['TABLE'] as $xmltable) {
|
|
if (!$result) { //Skip on error
|
|
continue;
|
|
}
|
|
$name = trim($xmltable['@']['NAME']);
|
|
$table = new xmldb_table($name);
|
|
$table->arr2xmldb_table($xmltable);
|
|
$this->tables[] = $table;
|
|
if (!$table->isLoaded()) {
|
|
$this->errormsg = 'Problem loading table ' . $name;
|
|
$this->debug($this->errormsg);
|
|
$result = false;
|
|
}
|
|
}
|
|
} else {
|
|
$this->errormsg = 'Missing TABLES section';
|
|
$this->debug($this->errormsg);
|
|
$result = false;
|
|
}
|
|
|
|
// Perform some general checks over tables
|
|
if ($result && $this->tables) {
|
|
// Check tables names are ok (lowercase, a-z _-)
|
|
if (!$this->checkNameValues($this->tables)) {
|
|
$this->errormsg = 'Some TABLES name values are incorrect';
|
|
$this->debug($this->errormsg);
|
|
$result = false;
|
|
}
|
|
// Compute prev/next.
|
|
$this->fixPrevNext($this->tables);
|
|
// Order tables
|
|
if ($result && !$this->orderTables($this->tables)) {
|
|
$this->errormsg = 'Error ordering the tables';
|
|
$this->debug($this->errormsg);
|
|
$result = false;
|
|
}
|
|
}
|
|
|
|
// Set some attributes
|
|
if ($result) {
|
|
$this->loaded = true;
|
|
}
|
|
$this->calculateHash();
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* This function calculate and set the hash of one xmldb_structure
|
|
* @param bool $recursive
|
|
*/
|
|
public function calculateHash($recursive = false) {
|
|
if (!$this->loaded) {
|
|
$this->hash = null;
|
|
} else {
|
|
$key = $this->name . $this->path . $this->comment;
|
|
if ($this->tables) {
|
|
foreach ($this->tables as $tbl) {
|
|
$table = $this->getTable($tbl->getName());
|
|
if ($recursive) {
|
|
$table->calculateHash($recursive);
|
|
}
|
|
$key .= $table->getHash();
|
|
}
|
|
}
|
|
$this->hash = md5($key);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This function will output the XML text for one structure
|
|
* @return string
|
|
*/
|
|
public function xmlOutput() {
|
|
$o = '<?xml version="1.0" encoding="UTF-8" ?>' . "\n";
|
|
$o.= '<XMLDB PATH="' . $this->path . '"';
|
|
$o.= ' VERSION="' . $this->version . '"';
|
|
if ($this->comment) {
|
|
$o.= ' COMMENT="' . htmlspecialchars($this->comment) . '"'."\n";
|
|
}
|
|
$rel = array_fill(0, count(explode('/', $this->path)), '..');
|
|
$rel = implode('/', $rel);
|
|
$o.= ' xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"'."\n";
|
|
$o.= ' xsi:noNamespaceSchemaLocation="'.$rel.'/lib/xmldb/xmldb.xsd"'."\n";
|
|
$o.= '>' . "\n";
|
|
// Now the tables
|
|
if ($this->tables) {
|
|
$o.= ' <TABLES>' . "\n";
|
|
foreach ($this->tables as $table) {
|
|
$o.= $table->xmlOutput();
|
|
}
|
|
$o.= ' </TABLES>' . "\n";
|
|
}
|
|
$o.= '</XMLDB>';
|
|
|
|
return $o;
|
|
}
|
|
|
|
/**
|
|
* This function returns the number of uses of one table inside
|
|
* a whole XMLDStructure. Useful to detect if the table must be
|
|
* locked. Return false if no uses are found.
|
|
* @param string $tablename
|
|
* @return mixed
|
|
*/
|
|
public function getTableUses($tablename) {
|
|
|
|
$uses = array();
|
|
|
|
// Check if some foreign key in the whole structure is using it
|
|
// (by comparing the reftable with the tablename)
|
|
if ($this->tables) {
|
|
foreach ($this->tables as $table) {
|
|
$keys = $table->getKeys();
|
|
if ($keys) {
|
|
foreach ($keys as $key) {
|
|
if ($key->getType() == XMLDB_KEY_FOREIGN) {
|
|
if ($tablename == $key->getRefTable()) {
|
|
$uses[] = 'table ' . $table->getName() . ' key ' . $key->getName();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Return result
|
|
if (!empty($uses)) {
|
|
return $uses;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This function returns the number of uses of one field inside
|
|
* a whole xmldb_structure. Useful to detect if the field must be
|
|
* locked. Return false if no uses are found.
|
|
* @param string $tablename
|
|
* @param string $fieldname
|
|
* @return mixed
|
|
*/
|
|
public function getFieldUses($tablename, $fieldname) {
|
|
|
|
$uses = array();
|
|
|
|
// Check if any key in the table is using it
|
|
$table = $this->getTable($tablename);
|
|
if ($keys = $table->getKeys()) {
|
|
foreach ($keys as $key) {
|
|
if (in_array($fieldname, $key->getFields()) ||
|
|
in_array($fieldname, $key->getRefFields())) {
|
|
$uses[] = 'table ' . $table->getName() . ' key ' . $key->getName();
|
|
}
|
|
}
|
|
}
|
|
// Check if any index in the table is using it
|
|
$table = $this->getTable($tablename);
|
|
if ($indexes = $table->getIndexes()) {
|
|
foreach ($indexes as $index) {
|
|
if (in_array($fieldname, $index->getFields())) {
|
|
$uses[] = 'table ' . $table->getName() . ' index ' . $index->getName();
|
|
}
|
|
}
|
|
}
|
|
// Check if some foreign key in the whole structure is using it
|
|
// By comparing the reftable and refields with the field)
|
|
if ($this->tables) {
|
|
foreach ($this->tables as $table) {
|
|
$keys = $table->getKeys();
|
|
if ($keys) {
|
|
foreach ($keys as $key) {
|
|
if ($key->getType() == XMLDB_KEY_FOREIGN) {
|
|
if ($tablename == $key->getRefTable()) {
|
|
$reffieds = $key->getRefFields();
|
|
if (in_array($fieldname, $key->getRefFields())) {
|
|
$uses[] = 'table ' . $table->getName() . ' key ' . $key->getName();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Return result
|
|
if (!empty($uses)) {
|
|
return $uses;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This function returns the number of uses of one key inside
|
|
* a whole xmldb_structure. Useful to detect if the key must be
|
|
* locked. Return false if no uses are found.
|
|
* @param string $tablename
|
|
* @param string $keyname
|
|
* @return mixed
|
|
*/
|
|
public function getKeyUses($tablename, $keyname) {
|
|
|
|
$uses = array();
|
|
|
|
// Check if some foreign key in the whole structure is using it
|
|
// (by comparing the reftable and reffields with the fields in the key)
|
|
$mytable = $this->getTable($tablename);
|
|
$mykey = $mytable->getKey($keyname);
|
|
if ($this->tables && $mykey) {
|
|
foreach ($this->tables as $table) {
|
|
$allkeys = $table->getKeys();
|
|
if ($allkeys) {
|
|
foreach ($allkeys as $key) {
|
|
if ($key->getType() != XMLDB_KEY_FOREIGN) {
|
|
continue;
|
|
}
|
|
if ($key->getRefTable() == $tablename &&
|
|
implode(',', $key->getRefFields()) == implode(',', $mykey->getFields())) {
|
|
$uses[] = 'table ' . $table->getName() . ' key ' . $key->getName();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Return result
|
|
if (!empty($uses)) {
|
|
return $uses;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This function returns the number of uses of one index inside
|
|
* a whole xmldb_structure. Useful to detect if the index must be
|
|
* locked. Return false if no uses are found.
|
|
* @param string $tablename
|
|
* @param string $indexname
|
|
* @return mixed
|
|
*/
|
|
public function getIndexUses($tablename, $indexname) {
|
|
|
|
$uses = array();
|
|
|
|
// Nothing to check, because indexes haven't uses! Leave it here
|
|
// for future checks...
|
|
|
|
// Return result
|
|
if (!empty($uses)) {
|
|
return $uses;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This function will return all the errors found in one structure
|
|
* looking recursively inside each table. Returns
|
|
* an array of errors or false
|
|
* @return mixed
|
|
*/
|
|
public function getAllErrors() {
|
|
|
|
$errors = array();
|
|
// First the structure itself
|
|
if ($this->getError()) {
|
|
$errors[] = $this->getError();
|
|
}
|
|
// Delegate to tables
|
|
if ($this->tables) {
|
|
foreach ($this->tables as $table) {
|
|
if ($tableerrors = $table->getAllErrors()) {
|
|
|
|
}
|
|
}
|
|
// Add them to the errors array
|
|
if ($tableerrors) {
|
|
$errors = array_merge($errors, $tableerrors);
|
|
}
|
|
}
|
|
// Return decision
|
|
if (count($errors)) {
|
|
return $errors;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|