Proyectos de Subversion Moodle

<?php
// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

/**
 * @package    tool_xmldb
 * @copyright  2003 onwards Eloy Lafuente (stronk7) {@link http://stronk7.com}
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */

/**
 * This class will look for data in the database that violates the foreign
 * key definitions found in the XMLDB definitions.
 *
 * Note that by default, this check does not complain about foreign key
 * violations from, say, a userid column defined as NOT NULL DEFAULT '0'.
 * Each 0 in that column will violate the foreign key, but we ignore them.
 * If you want a strict check performed, then add &strict=1 to the URL.
 *
 * @package    tool_xmldb
 * @copyright  2003 onwards Eloy Lafuente (stronk7) {@link http://stronk7.com}
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class check_foreign_keys extends XMLDBCheckAction {

    /**
     * Init method, every subclass will have its own
     */
    function init() {
        $this->introstr = 'confirmcheckforeignkeys';
        parent::init();

        // Set own core attributes

        // Set own custom attributes

        // Get needed strings
        $this->loadStrings(array(
            'key' => 'tool_xmldb',
            'violatedforeignkeys' => 'tool_xmldb',
            'noviolatedforeignkeysfound' => 'tool_xmldb',
            'violatedforeignkeysfound' => 'tool_xmldb',
            'violations' => 'tool_xmldb',
            'unknowntable' => 'tool_xmldb',
            'unknownfield' => 'tool_xmldb',
        ));
    }

    protected function check_table(xmldb_table $xmldb_table, array $metacolumns) {
        global $DB;
        $dbman = $DB->get_manager();

        $strictchecks = optional_param('strict', false, PARAM_BOOL);

        $o = '';
        $violatedkeys = array();

        // Keys
        if ($xmldb_keys = $xmldb_table->getKeys()) {
            $o.='        <ul>';
            foreach ($xmldb_keys as $xmldb_key) {
                // We are only interested in foreign keys.
                if (!in_array($xmldb_key->getType(), array(XMLDB_KEY_FOREIGN, XMLDB_KEY_FOREIGN_UNIQUE))) {
                    continue;
                }
                $o.='            <li>' . $this->str['key'] . ': ' . $xmldb_key->readableInfo() . ' ';

                $reftable = $xmldb_key->getRefTable();
                if (!$dbman->table_exists($reftable)) {
                    $o.='<font color="red">' . $this->str['unknowntable'] . '</font>';
                    // Add the missing index to the list
                    $violation = new stdClass();
                    $violation->string = 'fkunknowntable';
                    $violation->table = $xmldb_table;
                    $violation->key = $xmldb_key;
                    $violation->reftable = $reftable;
                    $violatedkeys[] = $violation;
                    continue;
                }

                // Work out the SQL to find key violations.
                $keyfields = $xmldb_key->getFields();
                $reffields = $xmldb_key->getRefFields();
                $joinconditions = array();
                $nullnessconditions = array();
                $params = array();
                foreach ($keyfields as $i => $field) {
                    if (!$dbman->field_exists($reftable, $reffields[$i])) {
                        $o.='<font color="red">' . $this->str['unknownfield'] . '</font>';
                        // Add the missing index to the list
                        $violation = new stdClass();
                        $violation->string = 'fkunknownfield';
                        $violation->table = $xmldb_table;
                        $violation->key = $xmldb_key;
                        $violation->reftable = $reftable;
                        $violation->reffield = $reffields[$i];
                        $violatedkeys[] = $violation;
                        continue 2;
                    }

                    $joinconditions[] = 't1.' . $field . ' = t2.' . $reffields[$i];
                    $xmldb_field = $xmldb_table->getField($field);
                    $default = $xmldb_field->getDefault();
                    if (!$xmldb_field->getNotNull()) {
                        $nullnessconditions[] = 't1.' . $field . ' IS NOT NULL';
                    } else if (!$strictchecks && ($default == '0' || !$default)) {
                        // We have a default of 0 or '' or something like that.
                        // These generate a lot of false-positives, so ignore them
                        // for now.
                        $nullnessconditions[] = 't1.' . $field . ' <> ?';
                        $params[] = $xmldb_field->getDefault();
                    }
                }
                $nullnessconditions[] = 't2.id IS NULL';
                $sql = 'SELECT count(1) FROM {' . $xmldb_table->getName() .
                        '} t1 LEFT JOIN {' . $reftable . '} t2 ON ' .
                        implode(' AND ', $joinconditions) . ' WHERE ' .
                        implode(' AND ', $nullnessconditions);

                // Check there are any problems in the database.
                $violations = $DB->count_records_sql($sql, $params);
                if ($violations == 0) {
                    $o.='<font color="green">' . $this->str['ok'] . '</font>';
                } else {
                    $o.='<font color="red">' . $this->str['violations'] . '</font>';
                    // Add the missing index to the list
                    $violation = new stdClass;
                    $violation->string = 'fkviolationdetails';
                    $violation->table = $xmldb_table;
                    $violation->key = $xmldb_key;
                    $violation->numviolations = $violations;
                    $violation->numrows = $DB->count_records($xmldb_table->getName());
                    $violation->sql = str_replace('count(1)', '*', $sql);
                    if (!empty($params)) {
                        $violation->sqlparams = '(' . implode(', ', $params) . ')';
                    } else {
                        $violation->sqlparams = '';
                    }
                    $violatedkeys[] = $violation;
                }
                $o.='</li>';
            }
            $o.='        </ul>';
        }

        return array($o, $violatedkeys);
    }

    protected function display_results(array $violatedkeys) {
        $r = '<table class="generaltable boxaligncenter boxwidthwide" border="0" cellpadding="5" cellspacing="0" id="results">';
        $r.= '  <tr><td class="generalboxcontent">';
        $r.= '    <h2 class="main">' . $this->str['searchresults'] . '</h2>';
        $r.= '    <p class="centerpara">' . $this->str['violatedforeignkeys'] . ': ' . count($violatedkeys) . '</p>';
        $r.= '  </td></tr>';
        $r.= '  <tr><td class="generalboxcontent">';

        // If we have found wrong integers inform about them
        if (count($violatedkeys)) {
            $r.= '    <p class="centerpara">' . $this->str['violatedforeignkeysfound'] . '</p>';
            $r.= '        <ul>';
            foreach ($violatedkeys as $violation) {
                $violation->tablename = $violation->table->getName();
                $violation->keyname = $violation->key->getName();

                $r.= '            <li>' .get_string($violation->string, 'tool_xmldb', $violation);
                if (!empty($violation->sql)) {
                    $r.= '<pre>' . s($violation->sql) . '; ' . s($violation->sqlparams) . '</pre>';
                }
                $r.= '</li>';
            }
            $r.= '        </ul>';
        } else {
            $r.= '    <p class="centerpara">' . $this->str['noviolatedforeignkeysfound'] . '</p>';
        }
        $r.= '  </td></tr>';
        $r.= '  <tr><td class="generalboxcontent">';
        // Add the complete log message
        $r.= '    <p class="centerpara">' . $this->str['completelogbelow'] . '</p>';
        $r.= '  </td></tr>';
        $r.= '</table>';

        return $r;
    }
}