PHP xmldb_file::loadXMLStructure方法代码示例

 /**
  * Invoke method, every class will have its own
  * returns true/false on completion, setting both
  * errormsg and output as necessary
  */
 function invoke()
 {
     parent::invoke();
     $result = true;
     /// Set own core attributes
     $this->does_generate = ACTION_NONE;
     //$this->does_generate = ACTION_GENERATE_HTML;
     /// These are always here
     global $CFG, $XMLDB;
     /// Do the job, setting $result as needed
     /// Get the dir containing the file
     $dirpath = required_param('dir', PARAM_PATH);
     $dirpath = $CFG->dirroot . $dirpath;
     /// Get the correct dir
     if (!empty($XMLDB->dbdirs)) {
         $dbdir =& $XMLDB->dbdirs[$dirpath];
         if ($dbdir) {
             /// Set some defaults
             $dbdir->xml_exists = false;
             $dbdir->xml_writeable = false;
             $dbdir->xml_loaded = false;
             ///Only if the directory exists
             if (!$dbdir->path_exists) {
                 return false;
             }
             $xmldb_file = new xmldb_file($dbdir->path . '/install.xml');
             ///Set the XML DTD and schema
             $xmldb_file->setDTD($CFG->dirroot . '/lib/xmldb/xmldb.dtd');
             $xmldb_file->setSchema($CFG->dirroot . '/lib/xmldb/xmldb.xsd');
             /// Set dbdir as necessary
             if ($xmldb_file->fileExists()) {
                 $dbdir->xml_exists = true;
             }
             if ($xmldb_file->fileWriteable()) {
                 $dbdir->xml_writeable = true;
             }
             /// Load the XML contents to structure
             $loaded = $xmldb_file->loadXMLStructure();
             if ($loaded && $xmldb_file->isLoaded()) {
                 $dbdir->xml_loaded = true;
                 $dbdir->filemtime = filemtime($dbdir->path . '/install.xml');
             }
             $dbdir->xml_file = $xmldb_file;
         } else {
             $this->errormsg = 'Wrong directory (' . $dirpath . ')';
             $result = false;
         }
     } else {
         $this->errormsg = 'XMLDB structure not found';
         $result = false;
     }
     /// Launch postaction if exists
     if ($this->getPostAction() && $result) {
         return $this->launch($this->getPostAction());
     }
     return $result;
 }

/**
 * Returns names of all known tables == tables that moodle knowns about.
 * @return array of lowercase table names
 */
function get_used_table_names()
{
    $table_names = array();
    $dbdirs = get_db_directories();
    foreach ($dbdirs as $dbdir) {
        $file = $dbdir . '/install.xml';
        $xmldb_file = new xmldb_file($file);
        if (!$xmldb_file->fileExists()) {
            continue;
        }
        $loaded = $xmldb_file->loadXMLStructure();
        $structure = $xmldb_file->getStructure();
        if ($loaded and $tables = $structure->getTables()) {
            foreach ($tables as $table) {
                $table_names[] = strtolower($table->name);
            }
        }
    }
    return $table_names;
}

 /**
  * Invoke method, every class will have its own
  * returns true/false on completion, setting both
  * errormsg and output as necessary
  */
 function invoke()
 {
     parent::invoke();
     $result = true;
     /// Set own core attributes
     $this->does_generate = ACTION_NONE;
     //$this->does_generate = ACTION_GENERATE_HTML;
     /// These are always here
     global $CFG, $XMLDB;
     /// Do the job, setting $result as needed
     /// Iterate over $XMLDB->dbdirs, loading their XML data to memory
     if ($XMLDB->dbdirs) {
         $dbdirs =& $XMLDB->dbdirs;
         foreach ($dbdirs as $dbdir) {
             /// Set some defaults
             $dbdir->xml_exists = false;
             $dbdir->xml_writeable = false;
             $dbdir->xml_loaded = false;
             ///Only if the directory exists
             if (!$dbdir->path_exists) {
                 continue;
             }
             $xmldb_file = new xmldb_file($dbdir->path . '/install.xml');
             /// Set dbdir as necessary
             if ($xmldb_file->fileExists()) {
                 $dbdir->xml_exists = true;
             }
             if ($xmldb_file->fileWriteable()) {
                 $dbdir->xml_writeable = true;
             }
             /// Load the XML contents to structure
             $loaded = $xmldb_file->loadXMLStructure();
             if ($loaded && $xmldb_file->isLoaded()) {
                 $dbdir->xml_loaded = true;
             }
             $dbdir->xml_file = $xmldb_file;
         }
     }
     return $result;
 }

 private function recreate_table($component, $tablename)
 {
     global $DB;
     unset($DB->donesetup);
     $manager = $DB->get_manager();
     $filename = get_component_directory($component) . "/db/install.xml";
     $xmldbfile = new xmldb_file($filename);
     if (!$xmldbfile->fileExists()) {
         throw new ddl_exception('ddlxmlfileerror', null, 'File does not exist');
     }
     $loaded = $xmldbfile->loadXMLStructure();
     if (!$loaded || !$xmldbfile->isLoaded()) {
         // Show info about the error if we can find it.
         if ($structure =& $xmldbfile->getStructure()) {
             if ($errors = $structure->getAllErrors()) {
                 throw new ddl_exception('ddlxmlfileerror', null, 'Errors found in XMLDB file: ' . implode(', ', $errors));
             }
         }
         throw new ddl_exception('ddlxmlfileerror', null, 'not loaded??');
     }
     $structure = $xmldbfile->getStructure();
     $table = $structure->getTable($tablename);
     $manager->create_table($table);
     $DB->donesetup = true;
 }

/**
 * Create temporary tables to speed up log generation
 */
function stats_temp_table_create()
{
    global $CFG, $DB;
    $dbman = $DB->get_manager();
    // We are going to use database_manager services
    stats_temp_table_drop();
    $xmlfile = $CFG->dirroot . '/lib/db/install.xml';
    $tables = array();
    // Allows for the additional xml files to be used (if necessary)
    $files = array($xmlfile => array('stats_daily' => array('temp_stats_daily'), 'stats_user_daily' => array('temp_stats_user_daily'), 'temp_enroled_template' => array('temp_enroled'), 'temp_log_template' => array('temp_log1', 'temp_log2')));
    foreach ($files as $file => $contents) {
        $xmldb_file = new xmldb_file($file);
        if (!$xmldb_file->fileExists()) {
            throw new ddl_exception('ddlxmlfileerror', null, 'File does not exist');
        }
        $loaded = $xmldb_file->loadXMLStructure();
        if (!$loaded || !$xmldb_file->isLoaded()) {
            throw new ddl_exception('ddlxmlfileerror', null, 'not loaded??');
        }
        $xmldb_structure = $xmldb_file->getStructure();
        foreach ($contents as $template => $names) {
            $table = $xmldb_structure->getTable($template);
            if (is_null($table)) {
                throw new ddl_exception('ddlunknowntable', null, 'The table ' . $name . ' is not defined in the file ' . $xmlfile);
            }
            $table->setNext(null);
            $table->setPrevious(null);
            foreach ($names as $name) {
                $named = clone $table;
                $named->setName($name);
                $tables[$name] = $named;
            }
        }
    }
    try {
        foreach ($tables as $table) {
            $dbman->create_temp_table($table);
        }
    } catch (Exception $e) {
        mtrace('Temporary table creation failed: ' . $e->getMessage());
        return false;
    }
    return true;
}

 /**
  * Invoke method, every class will have its own
  * returns true/false on completion, setting both
  * errormsg and output as necessary
  */
 function invoke()
 {
     parent::invoke();
     $result = true;
     /// Set own core attributes
     $this->does_generate = ACTION_GENERATE_HTML;
     /// These are always here
     global $CFG, $XMLDB, $DB, $OUTPUT;
     /// And we nedd some ddl suff
     $dbman = $DB->get_manager();
     /// Here we'll acummulate all the wrong fields found
     $problemsfound = array();
     /// Do the job, setting $result as needed
     /// Get the confirmed to decide what to do
     $confirmed = optional_param('confirmed', false, PARAM_BOOL);
     /// If  not confirmed, show confirmation box
     if (!$confirmed) {
         $o = '<table class="generalbox" border="0" cellpadding="5" cellspacing="0" id="notice">';
         $o .= '  <tr><td class="generalboxcontent">';
         $o .= '    <p class="centerpara">' . $this->str[$this->introstr] . '</p>';
         $o .= '    <table class="boxaligncenter" cellpadding="20"><tr><td>';
         $o .= '      <div class="singlebutton">';
         $o .= '        <form action="index.php?action=' . $this->title . '&amp;confirmed=yes&amp;sesskey=' . sesskey() . '" method="post"><fieldset class="invisiblefieldset">';
         $o .= '          <input type="submit" value="' . $this->str['yes'] . '" /></fieldset></form></div>';
         $o .= '      </td><td>';
         $o .= '      <div class="singlebutton">';
         $o .= '        <form action="index.php?action=main_view" method="post"><fieldset class="invisiblefieldset">';
         $o .= '          <input type="submit" value="' . $this->str['no'] . '" /></fieldset></form></div>';
         $o .= '      </td></tr>';
         $o .= '    </table>';
         $o .= '  </td></tr>';
         $o .= '</table>';
         $this->output = $o;
     } else {
         /// The back to edit table button
         $b = ' <p class="centerpara buttons">';
         $b .= '<a href="index.php">[' . $this->str['back'] . ']</a>';
         $b .= '</p>';
         /// Iterate over $XMLDB->dbdirs, loading their XML data to memory
         if ($XMLDB->dbdirs) {
             $dbdirs =& $XMLDB->dbdirs;
             $o = '<ul>';
             foreach ($dbdirs as $dbdir) {
                 /// Only if the directory exists
                 if (!$dbdir->path_exists) {
                     continue;
                 }
                 /// Load the XML file
                 $xmldb_file = new xmldb_file($dbdir->path . '/install.xml');
                 /// Only if the file exists
                 if (!$xmldb_file->fileExists()) {
                     continue;
                 }
                 /// Load the XML contents to structure
                 $loaded = $xmldb_file->loadXMLStructure();
                 if (!$loaded || !$xmldb_file->isLoaded()) {
                     echo $OUTPUT->notification('Errors found in XMLDB file: ' . $dbdir->path . '/install.xml');
                     continue;
                 }
                 /// Arriving here, everything is ok, get the XMLDB structure
                 $structure = $xmldb_file->getStructure();
                 $o .= '    <li>' . str_replace($CFG->dirroot . '/', '', $dbdir->path . '/install.xml');
                 /// Getting tables
                 if ($xmldb_tables = $structure->getTables()) {
                     $o .= '        <ul>';
                     /// Foreach table, process its fields
                     foreach ($xmldb_tables as $xmldb_table) {
                         /// Skip table if not exists
                         if (!$dbman->table_exists($xmldb_table)) {
                             continue;
                         }
                         /// Fetch metadata from physical DB. All the columns info.
                         if (!($metacolumns = $DB->get_columns($xmldb_table->getName()))) {
                             //// Skip table if no metacolumns is available for it
                             continue;
                         }
                         /// Table processing starts here
                         $o .= '            <li>' . $xmldb_table->getName();
                         /// Do the specific check.
                         list($output, $newproblems) = $this->check_table($xmldb_table, $metacolumns);
                         $o .= $output;
                         $problemsfound = array_merge($problemsfound, $newproblems);
                         $o .= '    </li>';
                         /// Give the script some more time (resetting to current if exists)
                         if ($currenttl = @ini_get('max_execution_time')) {
                             @ini_set('max_execution_time', $currenttl);
                         }
                     }
                     $o .= '        </ul>';
                 }
                 $o .= '    </li>';
             }
             $o .= '</ul>';
         }
         /// Create a report of the problems found.
//.........这里部分代码省略.........

 /**
  * Given one "real" tablename, create one temp table suitable for be used in backup/restore operations
  */
 public static function create_temptable_from_real_table($backupid, $realtablename, $temptablename)
 {
     global $CFG, $DB;
     $dbman = $DB->get_manager();
     // We are going to use database_manager services
     // As far as xmldb objects use a lot of circular references (prev and next) and we aren't destroying
     // them at all, that causes one memory leak of about 3M per backup execution, not problematic for
     // individual backups but critical for automated (multiple) ones.
     // So we are statically caching the xmldb_table definition here to produce the leak "only" once
     static $xmldb_tables = array();
     // Not cached, get it
     if (!isset($xmldb_tables[$realtablename])) {
         // Note: For now we are going to load the realtablename from core lib/db/install.xml
         // that way, any change in the "template" will be applied here automatically. If this causes
         // too much slow, we can always forget about the template and keep maintained the xmldb_table
         // structure inline - manually - here.
         // TODO: Right now, loading the whole lib/db/install.xml is "eating" 10M, we should
         // change our way here in order to decrease that memory usage
         $templatetablename = $realtablename;
         $targettablename = $temptablename;
         $xmlfile = $CFG->dirroot . '/lib/db/install.xml';
         $xmldb_file = new xmldb_file($xmlfile);
         if (!$xmldb_file->fileExists()) {
             throw new ddl_exception('ddlxmlfileerror', null, 'File does not exist');
         }
         $loaded = $xmldb_file->loadXMLStructure();
         if (!$loaded || !$xmldb_file->isLoaded()) {
             throw new ddl_exception('ddlxmlfileerror', null, 'not loaded??');
         }
         $xmldb_structure = $xmldb_file->getStructure();
         $xmldb_table = $xmldb_structure->getTable($templatetablename);
         if (is_null($xmldb_table)) {
             throw new ddl_exception('ddlunknowntable', null, 'The table ' . $templatetablename . ' is not defined in file ' . $xmlfile);
         }
         // Clean prev & next, we are alone
         $xmldb_table->setNext(null);
         $xmldb_table->setPrevious(null);
         // Rename
         $xmldb_table->setName($targettablename);
         // Cache it
         $xmldb_tables[$realtablename] = $xmldb_table;
     }
     // Arrived here, we have the table always in static cache, get it
     $xmldb_table = $xmldb_tables[$realtablename];
     // Set default backupid (not needed but this enforce any missing backupid). That's hackery in action!
     $xmldb_table->getField('backupid')->setDefault($backupid);
     $dbman->create_temp_table($xmldb_table);
     // And create it
 }

 /**
  * Reads the install.xml files for Moodle core and modules and returns an array of
  * xmldb_structure object with xmldb_table from these files.
  * @return xmldb_structure schema from install.xml files
  */
 public function get_install_xml_schema()
 {
     global $CFG;
     require_once $CFG->libdir . '/adminlib.php';
     $schema = new xmldb_structure('export');
     $schema->setVersion($CFG->version);
     $dbdirs = get_db_directories();
     foreach ($dbdirs as $dbdir) {
         $xmldb_file = new xmldb_file($dbdir . '/install.xml');
         if (!$xmldb_file->fileExists() or !$xmldb_file->loadXMLStructure()) {
             continue;
         }
         $structure = $xmldb_file->getStructure();
         $tables = $structure->getTables();
         foreach ($tables as $table) {
             $table->setPrevious(null);
             $table->setNext(null);
             $schema->addTable($table);
         }
     }
     return $schema;
 }

 /**
  * Finds all of the XMLDB files within a given plugin path and sets up the overlay table array to include
  * the tables defined within those plugins.
  *
  * @param string $path The path to look for modules in
  * @return array An array of extra overlay tables
  */
 protected static function load_plugin_xmldb($path)
 {
     global $CFG;
     require_once $CFG->libdir . '/ddllib.php';
     $tables = array();
     switch ($path) {
         case 'mod':
             $prefix = 'mod_';
             break;
         case 'course/format':
             $prefix = 'format_';
             break;
         default:
             return array();
     }
     $plugins = get_list_of_plugins($path);
     if ($plugins) {
         foreach ($plugins as $plugin) {
             if (!file_exists($CFG->dirroot . '/' . $path . '/' . $plugin . '/db/install.xml')) {
                 continue;
             }
             // Load the XMLDB file and pull the tables out of the XML strcture.
             $xmldbfile = new xmldb_file($CFG->dirroot . '/' . $path . '/' . $plugin . '/db/install.xml');
             if (!$xmldbfile->fileExists()) {
                 continue;
             }
             $xmldbfile->loadXMLStructure();
             $xmldbstructure = $xmldbfile->getStructure();
             $xmldbtables = $xmldbstructure->getTables();
             if (!empty($xmldbtables)) {
                 foreach ($xmldbtables as $xmldbtable) {
                     // Add each table to the list of overlay tables.
                     $tables[$xmldbtable->getName()] = $prefix . $plugin;
                 }
             }
         }
     }
     return $tables;
 }

function cleanup()
{
    global $DB;
    $dbman = $DB->get_manager();
    $tablename = student::TABLE;
    $tempname = $tablename . '_temp';
    $table = new xmldb_table($tempname);
    if ($dbman->table_exists($table)) {
        if (!$dbman->drop_table($table)) {
            mtrace(' <<< Could not remove temporary table: ' . $tempname);
            exit;
        }
    }
    // Create a temporary table by reading in the XMLDB file that defines the student enrolment table
    $xmldb_file = new xmldb_file(elispm::file('db/install.xml'));
    if (!$xmldb_file->fileExists() or !$xmldb_file->loadXMLStructure()) {
        continue;
    }
    $structure = $xmldb_file->getStructure();
    $tables = $structure->getTables();
    foreach ($tables as $table) {
        if ($table->getName() == $tablename) {
            $xml_temptable = $table;
            $xml_temptable->setName($tempname);
            $xml_temptable->setPrevious(null);
            $xml_temptable->setNext(null);
            $tempstructure = new xmldb_structure('temp');
            $tempstructure->addTable($xml_temptable);
            try {
                $dbman->install_from_xmldb_structure($tempstructure);
            } catch (ddl_change_structure_exception $e) {
                mtrace(' <<< Could not create temporary table: ' . $tempname);
                exit;
            }
            mtrace(' >>> Created temporary table: ' . $tempname);
        }
    }
    $xml_table = new xmldb_table($tablename);
    // Step 1. -- attempt to move unique values into the temporary table in a way that should leave some duplicates but
    //            will remove the vast majority of the them
    $sql = "INSERT INTO {{$tempname}}\n                SELECT id, classid, userid, enrolmenttime, MIN(completetime) AS completetime, endtime, completestatusid,\n                       grade, credits, locked\n                FROM {{$tablename}}\n                GROUP BY classid, userid, completestatusid, grade, credits, locked";
    try {
        $DB->execute($sql);
    } catch (dml_exception $e) {
        mtrace(' <<< Could not move duplicate records from: ' . $tablename . ' into: ' . $tempname);
        exit;
    }
    mtrace(' >>> Moved duplicate records from: ' . $tablename . ' into: ' . $tempname);
    // Step 2. -- detect if we still have any duplicates remaining
    $sql = "SELECT id, COUNT(*) AS count, classid, userid, enrolmenttime, completetime, completestatusid, grade, credits, locked\n            FROM {{$tempname}}\n            GROUP BY classid, userid\n            ORDER BY count DESC, classid ASC, userid ASC";
    if ($dupcount = $DB->get_records_sql($sql, array(), 0, 1)) {
        $dupe = current($dupcount);
        if ($dupe->count > 1) {
            mtrace(' <<< Duplicate records still exist in temporary table');
        } else {
            mtrace(' >>> No duplicate records exist in temporary table');
        }
    }
    // Step 3. -- at this point duplicate data was found, so we will need to process each record in turn to find the first
    //            legitimate record that should be kept
    if ($rs = $DB->get_recordset_sql($sql)) {
        foreach ($rs as $dupe) {
            if ($dupe->count <= 1) {
                continue;
            }
            $classid = $dupe->classid;
            $userid = $dupe->userid;
            $goodid = 0;
            // The ID of the record we will keep
            // Find the record marked "complete" or "failed" and locked with the earliest completion time
            $sql2 = "SELECT id, completestatusid, grade locked\n                     FROM {{$tempname}}\n                     WHERE userid = {$userid}\n                     AND classid = {$classid}\n                     ORDER BY completetime ASC, completestatusid ASC, locked ASC";
            if ($rs2 = $DB->get_recordset_sql($sql2)) {
                foreach ($rs2 as $rec) {
                    // Store the last record ID just in case we need it for cleanup
                    $lastid = $rec->id;
                    // Don't bother looking at remaining records if we have found a record to keep
                    if (!empty($goodid)) {
                        continue;
                    }
                    if ($rec->completestatusid != 0 && ($rec->locked = 1)) {
                        $goodid = $rec->id;
                    }
                }
                $rs2->close();
                // We need to make sure we have a record ID to keep, if we found no "complete" and locked
                // records, let's just keep the last record we saw
                if (empty($goodid)) {
                    $goodid = $lastid;
                }
                $select = 'classid = ' . $classid . ' AND userid = ' . $userid . ' AND id != ' . $goodid;
            }
            // If we have some records to clean up, let's do that now
            if (!empty($select)) {
                $status = true;
                try {
                    $DB->delete_records_select($tempname, $select);
                } catch (dml_exception $e) {
                    mtrace(' <<< Could not clean up duplicate ' . $tempname . ' records for userid = ' . $userid . ', classid = ' . $classid);
                    $status = false;
                }
//.........这里部分代码省略.........