PHP MDB2::loadClass方法代码示例

 /**
  * Tests that the MDB2::loadClass() method correctly loads classes.
  */
 function test_loadClass()
 {
     $this->assertTrue(MDB2::loadClass('MDB2', false), 'loadClass');
     // Suppress handling of PEAR errors while testing next case
     PEAR::pushErrorHandling(null);
     $result = MDB2::loadClass('null', false);
     $this->assertTrue(is_a($result, 'pear_error'), 'loadClass');
     PEAR::popErrorHandling();
 }

 /**
  * Dump a previously parsed database structure in the Metabase schema
  * XML based format suitable for the Metabase parser. This function
  * may optionally dump the database definition with initialization
  * commands that specify the data that is currently present in the tables.
  *
  * @param array $database_definition multi dimensional array that contains the current definition
  * @param array $arguments           associative array that takes pairs of tag
  * names and values that define dump options.
  *                 <pre>array (
  *                     'output_mode'    =>    String
  *                         'file' :   dump into a file
  *                         default:   dump using a function
  *                     'output'        =>    String
  *                         depending on the 'Output_Mode'
  *                                  name of the file
  *                                  name of the function
  *                     'end_of_line'        =>    String
  *                         end of line delimiter that should be used
  *                         default: "\n"
  *                 );</pre>
  * @param int   $dump                Int that determines what data to dump
  *              + MDB2_SCHEMA_DUMP_ALL       : the entire db
  *              + MDB2_SCHEMA_DUMP_STRUCTURE : only the structure of the db
  *              + MDB2_SCHEMA_DUMP_CONTENT   : only the content of the db
  *
  * @return bool|MDB2_Error MDB2_OK or error object
  * @access public
  */
 function dumpDatabase($database_definition, $arguments, $dump = MDB2_SCHEMA_DUMP_ALL)
 {
     $class_name = $this->options['writer'];
     $result = MDB2::loadClass($class_name, $this->db->getOption('debug'));
     if (PEAR::isError($result)) {
         return $result;
     }
     // get initialization data
     if (isset($database_definition['tables']) && is_array($database_definition['tables']) && $dump == MDB2_SCHEMA_DUMP_ALL || $dump == MDB2_SCHEMA_DUMP_CONTENT) {
         foreach ($database_definition['tables'] as $table_name => $table) {
             $fields = array();
             $fieldsq = array();
             foreach ($table['fields'] as $field_name => $field) {
                 $fields[$field_name] = $field['type'];
                 $fieldsq[] = $this->db->quoteIdentifier($field_name, true);
             }
             $query = 'SELECT ' . implode(', ', $fieldsq) . ' FROM ';
             $query .= $this->db->quoteIdentifier($table_name, true);
             $data = $this->db->queryAll($query, $fields, MDB2_FETCHMODE_ASSOC);
             if (PEAR::isError($data)) {
                 return $data;
             }
             if (!empty($data)) {
                 $initialization = array();
                 $lob_buffer_length = $this->db->getOption('lob_buffer_length');
                 foreach ($data as $row) {
                     $rows = array();
                     foreach ($row as $key => $lob) {
                         if (is_resource($lob)) {
                             $value = '';
                             while (!feof($lob)) {
                                 $value .= fread($lob, $lob_buffer_length);
                             }
                             $row[$key] = $value;
                         }
                         $rows[] = array('name' => $key, 'group' => array('type' => 'value', 'data' => $row[$key]));
                     }
                     $initialization[] = array('type' => 'insert', 'data' => array('field' => $rows));
                 }
                 $database_definition['tables'][$table_name]['initialization'] = $initialization;
             }
         }
     }
     $writer = new $class_name($this->options['valid_types']);
     return $writer->dumpDatabase($database_definition, $arguments, $dump);
 }

<?php

require_once "CommonTools.php";
// Let's do a little hack. We need the configuration information now, because
// we must get the DBinterface with the help of rootDir. So, we must
// create configuration method in this point
$configurations = new Configurations();
// Connection $conn is made in DBInterface.php
require_once dirname(__FILE__) . "/../DBInterface.php";
// To the ageLessThan function
define("TIMEUNIT_DAYS", "days");
define("TIMEUNIT_MINUTES", "minutes");
// Warnings disabled
@MDB2::loadClass("MDB2_Driver_Datatype_Common", false);
@MDB2::loadClass("MDB2_Date", false);
@($MDB2Datatype = new MDB2_Driver_Datatype_Common());
$conn->loadModule('Datatype');
class Database
{
    var $configurations;
    var $page;
    var $debugger;
    var $connection;
    function Database()
    {
        global $configurations, $page, $debugger;
        $this->configurations =& $configurations;
        $this->page =& $page;
        $this->debugger =& $debugger;
        /*
        Tämä kaikki on aika turhaa, kun otaxille siirryttäessä tein 

 /**
  * loads a module
  *
  * @param   string  name of the module that should be loaded
  *                  (only used for error messages)
  * @param   string  name of the property into which the class will be loaded
  * @param   bool    if the class to load for the module is specific to the
  *                  phptype
  *
  * @return  object  on success a reference to the given module is returned
  *                  and on failure a PEAR error
  *
  * @access  public
  */
 function loadModule($module, $property = null, $phptype_specific = null)
 {
     if (!$property) {
         $property = strtolower($module);
     }
     if (!isset($this->{$property})) {
         $version = $phptype_specific;
         if ($phptype_specific !== false) {
             $version = true;
             $class_name = 'MDB2_Driver_' . $module . '_' . $this->phptype;
             $file_name = str_replace('_', DIRECTORY_SEPARATOR, $class_name) . '.php';
         }
         if ($phptype_specific === false || !MDB2::classExists($class_name) && !MDB2::fileExists($file_name)) {
             $version = false;
             $class_name = 'MDB2_' . $module;
             $file_name = str_replace('_', DIRECTORY_SEPARATOR, $class_name) . '.php';
         }
         $err = MDB2::loadClass($class_name, $this->getOption('debug'));
         if ((new PEAR())->isError($err)) {
             return $err;
         }
         // load module in a specific version
         if ($version) {
             if (method_exists($class_name, 'getClassName')) {
                 $class_name_new = call_user_func(array($class_name, 'getClassName'), $this->db_index);
                 if ($class_name != $class_name_new) {
                     $class_name = $class_name_new;
                     $err = MDB2::loadClass($class_name, $this->getOption('debug'));
                     if ((new PEAR())->isError($err)) {
                         return $err;
                     }
                 }
             }
         }
         if (!MDB2::classExists($class_name)) {
             $err = $this->raiseError(MDB2_ERROR_LOADMODULE, null, null, "unable to load module '{$module}' into property '{$property}'", __FUNCTION__);
             return $err;
         }
         $this->{$property} = new $class_name($this->db_index);
         $this->modules[$module] = $this->{$property};
         if ($version) {
             // this will be used in the connect method to determine if the module
             // needs to be loaded with a different version if the server
             // version changed in between connects
             $this->loaded_version_modules[] = $property;
         }
     }
     return $this->{$property};
 }

 /**
  * Parse a changeset definition file by creating a schema
  * parser object and passing the file contents as parser input data stream.
  *
  * @param string the changeset schema file.
  * @param array associative array that the defines the text string values
  *              that are meant to be used to replace the variables that are
  *              used in the schema description.
  * @param bool make function fail on invalid names
  * @param array database structure definition
  * @access public
  */
 function parseDictionaryDefinitionFile($input_file, $variables = array(), $fail_on_invalid_names = true, $structure = false)
 {
     $dtd_file = $this->options['dtd_file'];
     if ($dtd_file) {
         require_once 'XML/DTD/XmlValidator.php';
         $dtd = new XML_DTD_XmlValidator();
         if (!$dtd->isValid($dtd_file, $input_file)) {
             return $this->customRaiseError(MDB2_SCHEMA_ERROR_PARSE, null, null, $dtd->getMessage());
         }
     }
     require_once "MDB2/Schema/ParserDictionary.php";
     $class_name = 'MDB2_Dictionary_Parser';
     $result = MDB2::loadClass($class_name, $this->db->getOption('debug'));
     if (PEAR::isError($result)) {
         return $result;
     }
     $parser = new $class_name($variables, $fail_on_invalid_names, $structure, $this->options['valid_types'], $this->options['force_defaults']);
     $class_name = 'MDB2_Schema_Validate';
     $parser->val = new $class_name($fail_on_invalid_names, $this->options['valid_types'], $this->options['force_defaults']);
     $result = $parser->setInputFile($input_file);
     if (PEAR::isError($result)) {
         return $result;
     }
     $result = $parser->parse();
     if (PEAR::isError($result)) {
         return $result;
     }
     if (PEAR::isError($parser->error)) {
         return $parser->error;
     }
     $dictionary = $parser->dictionary_definition;
     return $dictionary;
 }

 /**
  * Tests that the MDB2::loadClass() method correctly loads classes.
  * @dataProvider provider
  */
 public function test_loadClass($ci)
 {
     $this->manualSetUp($ci);
     $this->assertTrue(MDB2::loadClass('MDB2', false), 'loadClass');
     // Suppress handling of PEAR errors while testing next case
     $this->db->pushErrorHandling(null);
     $result = MDB2::loadClass('null', false);
     $this->assertTrue(is_object($result) && is_a($result, 'pear_error'), 'loadClass');
     $this->db->popErrorHandling();
 }