Source for file database.php

Documentation is available at database.php

  1. <?php
  2. /**
  3.  * @package     Joomla.Installation
  4.  * @subpackage  Model
  5.  *
  6.  * @copyright   Copyright (C) 2005 - 2013 Open Source Matters, Inc. All rights reserved.
  7.  * @license     GNU General Public License version 2 or later; see LICENSE.txt
  8.  */
  9.  
  10. defined('_JEXEC') or die;
  11.  
  12. /**
  13.  * Database configuration model for the Joomla Core Installer.
  14.  *
  15.  * @package  Joomla.Installation
  16.  * @since    3.1
  17.  */
  18. class InstallationModelDatabase extends JModelBase
  19. {
  20.     /**
  21.      * The generated user ID
  22.      *
  23.      * @var    integer 
  24.      * @since  3.1
  25.      */
  26.     protected static $userId = 0;
  27.  
  28.     /**
  29.      * Generates the user ID
  30.      *
  31.      * @return  integer  The user ID
  32.      *
  33.      * @since   3.1
  34.      */
  35.     protected static function generateRandUserId()
  36.     {
  37.         $session = JFactory::getSession();
  38.         $randUserId = $session->get('randUserId');
  39.  
  40.         if (empty($randUserId))
  41.         {
  42.             // Create the ID for the root user only once and store in session
  43.             $randUserId = mt_rand(1, 1000);
  44.             $session->set('randUserId', $randUserId);
  45.         }
  46.  
  47.         return $randUserId;
  48.     }
  49.  
  50.     /**
  51.      * Resets the user ID
  52.      *
  53.      * @return  void 
  54.      *
  55.      * @since   3.1
  56.      */
  57.     public static function resetRandUserId()
  58.     {
  59.         self::$userId = 0;
  60.         $session = JFactory::getSession();
  61.         $session->set('randUserId', self::$userId);
  62.     }
  63.  
  64.     /**
  65.      * Retrieves the default user ID and sets it if necessary
  66.      *
  67.      * @return  integer  The user ID
  68.      *
  69.      * @since   3.1
  70.      */
  71.     public static function getUserId()
  72.     {
  73.         if (!self::$userId)
  74.         {
  75.             self::$userId = self::generateRandUserId();
  76.         }
  77.  
  78.         return self::$userId;
  79.     }
  80.  
  81.     /**
  82.      * Method to initialise the database
  83.      *
  84.      * @param   array  $options  The options to use for configuration
  85.      *
  86.      * @return  boolean  True on success
  87.      *
  88.      * @since   3.1
  89.      */
  90.     public function initialise($options)
  91.     {
  92.         // Get the application
  93.         /* @var InstallationApplicationWeb $app */
  94.         $app = JFactory::getApplication();
  95.  
  96.         // Get the options as a object for easier handling.
  97.         $options = JArrayHelper::toObject($options);
  98.  
  99.         // Load the back-end language files so that the DB error messages work
  100.         $lang = JFactory::getLanguage();
  101.         $currentLang = $lang->getTag();
  102.  
  103.         // Load the selected language
  104.         if (JLanguage::exists($currentLang, JPATH_ADMINISTRATOR))
  105.         {
  106.             $lang->load('joomla', JPATH_ADMINISTRATOR, $currentLang, true);
  107.         }
  108.         // Pre-load en-GB in case the chosen language files do not exist
  109.         else
  110.         {
  111.             $lang->load('joomla', JPATH_ADMINISTRATOR, 'en-GB', true);
  112.         }
  113.  
  114.         // Ensure a database type was selected.
  115.         if (empty($options->db_type))
  116.         {
  117.             $app->enqueueMessage(JText::_('INSTL_DATABASE_INVALID_TYPE'), 'notice');
  118.             return false;
  119.         }
  120.  
  121.         // Ensure that a hostname and user name were input.
  122.         if (empty($options->db_host) || empty($options->db_user))
  123.         {
  124.             $app->enqueueMessage(JText::_('INSTL_DATABASE_INVALID_DB_DETAILS'), 'notice');
  125.             return false;
  126.         }
  127.  
  128.         // Ensure that a database name was input.
  129.         if (empty($options->db_name))
  130.         {
  131.             $app->enqueueMessage(JText::_('INSTL_DATABASE_EMPTY_NAME'), 'notice');
  132.             return false;
  133.         }
  134.  
  135.         // Validate database table prefix.
  136.         if (!preg_match('#^[a-zA-Z]+[a-zA-Z0-9_]*$#', $options->db_prefix))
  137.         {
  138.             $app->enqueueMessage(JText::_('INSTL_DATABASE_PREFIX_INVALID_CHARS'), 'notice');
  139.             return false;
  140.         }
  141.  
  142.         // Validate length of database table prefix.
  143.         if (strlen($options->db_prefix) > 15)
  144.         {
  145.             $app->enqueueMessage(JText::_('INSTL_DATABASE_FIX_TOO_LONG'), 'notice');
  146.             return false;
  147.         }
  148.  
  149.         // Validate length of database name.
  150.         if (strlen($options->db_name) > 64)
  151.         {
  152.             $app->enqueueMessage(JText::_('INSTL_DATABASE_NAME_TOO_LONG'), 'notice');
  153.             return false;
  154.         }
  155.  
  156.         // Get a database object.
  157.         try
  158.         {
  159.             return InstallationHelperDatabase::getDbo(
  160.                 $options->db_type, $options->db_host, $options->db_user, $options->db_pass, $options->db_name, $options->db_prefix, $options->db_select
  161.             );
  162.         }
  163.         catch (RuntimeException $e)
  164.         {
  165.             $app->enqueueMessage(JText::sprintf('INSTL_DATABASE_COULD_NOT_CONNECT', $e->getMessage()), 'notice');
  166.             return false;
  167.         }
  168.     }
  169.  
  170.     /**
  171.      * Method to create a new database.
  172.      *
  173.      * @param   array  $options  The configuration options
  174.      *
  175.      * @return    boolean    True on success.
  176.      *
  177.      * @since    3.1
  178.      */
  179.     public function createDatabase($options)
  180.     {
  181.         // Get the application
  182.         /* @var InstallationApplicationWeb $app */
  183.         $app = JFactory::getApplication();
  184.  
  185.         // Disable autoselect database before it's created
  186.         $tmpSelect = true;
  187.  
  188.         if (isset($options['db_select']))
  189.         {
  190.             $tmpSelect = $options['db_select'];
  191.         }
  192.         $options['db_select'] = false;
  193.  
  194.         if (!$db = $this->initialise($options))
  195.         {
  196.             return false;
  197.         }
  198.  
  199.         // Get the options as a object for easier handling.
  200.         $options = JArrayHelper::toObject($options);
  201.  
  202.         // Check database version.
  203.         $type = $options->db_type;
  204.  
  205.         try
  206.         {
  207.             $db_version = $db->getVersion();
  208.         }
  209.         catch (RuntimeException $e)
  210.         {
  211.             $app->enqueueMessage(JText::sprintf('INSTL_DATABASE_COULD_NOT_CONNECT', $e->getMessage()), 'notice');
  212.             return false;
  213.         }
  214.  
  215.         if (!$db->isMinimumVersion())
  216.         {
  217.             $app->enqueueMessage(JText::sprintf('INSTL_DATABASE_INVALID_' . strtoupper($type) . '_VERSION', $db_version), 'notice');
  218.             return false;
  219.         }
  220.  
  221.         if (($type == 'mysql') || ($type == 'mysqli'))
  222.         {
  223.             // @internal MySQL versions pre 5.1.6 forbid . / or \ or NULL
  224.             if ((preg_match('#[\\\/\.\0]#', $options->db_name)) && (!version_compare($db_version, '5.1.6', '>=')))
  225.             {
  226.                 $app->enqueueMessage(JText::sprintf('INSTL_DATABASE_INVALID_NAME', $db_version), 'notice');
  227.                 return false;
  228.             }
  229.         }
  230.  
  231.         // @internal Check for spaces in beginning or end of name
  232.         if (strlen(trim($options->db_name)) <> strlen($options->db_name))
  233.         {
  234.             $app->enqueueMessage(JText::_('INSTL_DATABASE_NAME_INVALID_SPACES'), 'notice');
  235.             return false;
  236.         }
  237.  
  238.         // @internal Check for asc(00) Null in name
  239.         if (strpos($options->db_name, chr(00)) !== false)
  240.         {
  241.             $app->enqueueMessage(JText::_('INSTL_DATABASE_NAME_INVALID_CHAR'), 'notice');
  242.             return false;
  243.         }
  244.  
  245.         // PostgreSQL database older than version 9.0.0 needs to run 'CREATE LANGUAGE' to create function.
  246.         if (($options->db_type == 'postgresql') && (version_compare($db_version, '9.0.0', '<')))
  247.         {
  248.             $db->setQuery("CREATE LANGUAGE plpgsql");
  249.             $db->execute();
  250.         }
  251.  
  252.         // Get database's UTF support
  253.         $utfSupport = $db->hasUTFSupport();
  254.  
  255.         // Try to select the database
  256.         try
  257.         {
  258.             $db->select($options->db_name);
  259.         }
  260.         catch (RuntimeException $e)
  261.         {
  262.             // If the database could not be selected, attempt to create it and then select it.
  263.             if ($this->createDB($db, $options, $utfSupport))
  264.             {
  265.                 $db->select($options->db_name);
  266.             }
  267.             else
  268.             {
  269.                 $app->enqueueMessage(JText::sprintf('INSTL_DATABASE_ERROR_CREATE', $options->db_name), 'notice');
  270.                 return false;
  271.             }
  272.         }
  273.  
  274.         $options = (array) $options;
  275.  
  276.         // Remove *_errors value
  277.         foreach ($options as $i => $option)
  278.         {
  279.             if (isset($i['1']) && $i['1'] == '*')
  280.             {
  281.                 unset($options[$i]);
  282.                 break;
  283.             }
  284.         }
  285.         $options = array_merge(array('db_created' => 1), $options);
  286.  
  287.         // Restore autoselect value after database creation
  288.         $options['db_select'] = $tmpSelect;
  289.  
  290.         $session = JFactory::getSession();
  291.         $session->set('setup.options', $options);
  292.  
  293.         return true;
  294.     }
  295.  
  296.     /**
  297.      * Method to process the old database
  298.      *
  299.      * @param   array  $options  The options array
  300.      *
  301.      * @return  boolean  True on success
  302.      *
  303.      * @since   3.1
  304.      */
  305.     public function handleOldDatabase($options)
  306.     {
  307.         if (!isset($options['db_created']) || !$options['db_created'])
  308.         {
  309.             return $this->createDatabase($options);
  310.         }
  311.  
  312.         if (!$db = $this->initialise($options))
  313.         {
  314.             return false;
  315.         }
  316.  
  317.         // Get the options as a object for easier handling.
  318.         $options = JArrayHelper::toObject($options);
  319.  
  320.         // Set the character set to UTF-8 for pre-existing databases.
  321.         $this->setDatabaseCharset($db, $options->db_name);
  322.  
  323.         // Should any old database tables be removed or backed up?
  324.         if ($options->db_old == 'remove')
  325.         {
  326.             // Attempt to delete the old database tables.
  327.             if (!$this->deleteDatabase($db, $options->db_prefix))
  328.             {
  329.                 // Message queued by method, simply return
  330.                 return false;
  331.             }
  332.         }
  333.         else
  334.         {
  335.             // If the database isn't being deleted, back it up.
  336.             if (!$this->backupDatabase($db, $options->db_prefix))
  337.             {
  338.                 return false;
  339.             }
  340.         }
  341.  
  342.         return true;
  343.     }
  344.  
  345.     /**
  346.      * Method to create the database tables
  347.      *
  348.      * @param   array  $options  The options array
  349.      *
  350.      * @return  boolean  True on success
  351.      *
  352.      * @since   3.1
  353.      */
  354.     public function createTables($options)
  355.     {
  356.         // Get the application
  357.         /* @var InstallationApplicationWeb $app */
  358.         $app = JFactory::getApplication();
  359.  
  360.         if (!isset($options['db_created']) || !$options['db_created'])
  361.         {
  362.             return $this->createDatabase($options);
  363.         }
  364.  
  365.         if (!$db = $this->initialise($options))
  366.         {
  367.             return false;
  368.         }
  369.  
  370.         // Get the options as a object for easier handling.
  371.         $options = JArrayHelper::toObject($options);
  372.  
  373.         // Check database type.
  374.         $type = $options->db_type;
  375.  
  376.         // Set the character set to UTF-8 for pre-existing databases.
  377.         $this->setDatabaseCharset($db, $options->db_name);
  378.  
  379.         // Set the appropriate schema script based on UTF-8 support.
  380.         if ($type == 'mysqli' || $type == 'mysql')
  381.         {
  382.             $schema = 'sql/mysql/joomla.sql';
  383.         }
  384.         elseif ($type == 'sqlsrv' || $type == 'sqlazure')
  385.         {
  386.             $schema = 'sql/sqlazure/joomla.sql';
  387.         }
  388.         else
  389.         {
  390.             $schema = 'sql/' . $type . '/joomla.sql';
  391.         }
  392.  
  393.         // Check if the schema is a valid file
  394.         if (!is_file($schema))
  395.         {
  396.             $app->enqueueMessage(JText::sprintf('INSTL_ERROR_DB', JText::_('INSTL_DATABASE_NO_SCHEMA')), 'notice');
  397.             return false;
  398.         }
  399.  
  400.         // Attempt to import the database schema.
  401.         if (!$this->populateDatabase($db, $schema))
  402.         {
  403.             return false;
  404.         }
  405.  
  406.         // Attempt to update the table #__schema.
  407.         $pathPart = JPATH_ADMINISTRATOR . '/components/com_admin/sql/updates/';
  408.  
  409.         if ($type == 'mysqli' || $type == 'mysql')
  410.         {
  411.             $pathPart .= 'mysql/';
  412.         }
  413.         elseif ($type == 'sqlsrv' || $type == 'sqlazure')
  414.         {
  415.             $pathPart .= 'sqlazure/';
  416.         }
  417.         else
  418.         {
  419.             $pathPart .= $type . '/';
  420.         }
  421.         $files = JFolder::files($pathPart, '\.sql$');
  422.  
  423.         if (empty($files))
  424.         {
  425.             $app->enqueueMessage(JText::_('INSTL_ERROR_INITIALISE_SCHEMA'), 'notice');
  426.             return false;
  427.         }
  428.         $version = '';
  429.  
  430.         foreach ($files as $file)
  431.         {
  432.             if (version_compare($version, JFile::stripExt($file)) < 0)
  433.             {
  434.                 $version = JFile::stripExt($file);
  435.             }
  436.         }
  437.         $query = $db->getQuery(true)
  438.             ->insert($db->quoteName('#__schemas'))
  439.             ->columns(
  440.                 array(
  441.                     $db->quoteName('extension_id'),
  442.                     $db->quoteName('version_id')
  443.                 )
  444.             )
  445.             ->values('700, ' . $db->quote($version));
  446.         $db->setQuery($query);
  447.  
  448.         try
  449.         {
  450.             $db->execute();
  451.         }
  452.         catch (RuntimeException $e)
  453.         {
  454.             $app->enqueueMessage($e->getMessage(), 'notice');
  455.             return false;
  456.         }
  457.  
  458.         // Attempt to refresh manifest caches
  459.         $query->clear()
  460.             ->select('*')
  461.             ->from('#__extensions');
  462.         $db->setQuery($query);
  463.  
  464.         $return = true;
  465.  
  466.         try
  467.         {
  468.             $extensions = $db->loadObjectList();
  469.         }
  470.         catch (RuntimeException $e)
  471.         {
  472.             $app->enqueueMessage($e->getMessage(), 'notice');
  473.             $return = false;
  474.         }
  475.  
  476.         JFactory::$database = $db;
  477.         $installer = JInstaller::getInstance();
  478.  
  479.         foreach ($extensions as $extension)
  480.         {
  481.             if (!$installer->refreshManifestCache($extension->extension_id))
  482.             {
  483.                 $app->enqueueMessage(JText::sprintf('INSTL_DATABASE_COULD_NOT_REFRESH_MANIFEST_CACHE', $extension->name), 'notice');
  484.                 return false;
  485.             }
  486.         }
  487.  
  488.         // Load the localise.sql for translating the data in joomla.sql
  489.         if ($type == 'mysqli' || $type == 'mysql')
  490.         {
  491.             $dblocalise = 'sql/mysql/localise.sql';
  492.         }
  493.         elseif ($type == 'sqlsrv' || $type == 'sqlazure')
  494.         {
  495.             $dblocalise = 'sql/sqlazure/localise.sql';
  496.         }
  497.         else
  498.         {
  499.             $dblocalise = 'sql/' . $type . '/localise.sql';
  500.         }
  501.  
  502.         if (is_file($dblocalise))
  503.         {
  504.             if (!$this->populateDatabase($db, $dblocalise))
  505.             {
  506.                 return false;
  507.             }
  508.         }
  509.  
  510.         // Handle default backend language setting. This feature is available for localized versions of Joomla.
  511.         $app = JFactory::getApplication();
  512.         $languages = $app->getLocaliseAdmin($db);
  513.  
  514.         if (in_array($options->language, $languages['admin']) || in_array($options->language, $languages['site']))
  515.         {
  516.             // Build the language parameters for the language manager.
  517.             $params = array();
  518.  
  519.             // Set default administrator/site language to sample data values:
  520.             $params['administrator'] = 'en-GB';
  521.             $params['site'] = 'en-GB';
  522.  
  523.             if (in_array($options->language, $languages['admin']))
  524.             {
  525.                 $params['administrator'] = $options->language;
  526.             }
  527.  
  528.             if (in_array($options->language, $languages['site']))
  529.             {
  530.                 $params['site'] = $options->language;
  531.             }
  532.             $params = json_encode($params);
  533.  
  534.             // Update the language settings in the language manager.
  535.             $query->clear()
  536.                 ->update($db->quoteName('#__extensions'))
  537.                 ->set($db->quoteName('params') . ' = ' . $db->quote($params))
  538.                 ->where($db->quoteName('element') . ' = ' . $db->quote('com_languages'));
  539.             $db->setQuery($query);
  540.  
  541.             try
  542.             {
  543.                 $db->execute();
  544.             }
  545.             catch (RuntimeException $e)
  546.             {
  547.                 $app->enqueueMessage($e->getMessage(), 'notice');
  548.                 $return = false;
  549.             }
  550.         }
  551.  
  552.         return $return;
  553.     }
  554.  
  555.     /**
  556.      * Method to install the sample data
  557.      *
  558.      * @param   array  $options  The options array
  559.      *
  560.      * @return  boolean  True on success
  561.      *
  562.      * @since   3.1
  563.      */
  564.     public function installSampleData($options)
  565.     {
  566.         // Get the application
  567.         /* @var InstallationApplicationWeb $app */
  568.         $app = JFactory::getApplication();
  569.  
  570.         if (!isset($options['db_created']) || !$options['db_created'])
  571.         {
  572.             return $this->createDatabase($options);
  573.         }
  574.  
  575.         if (!$db = $this->initialise($options))
  576.         {
  577.             return false;
  578.         }
  579.  
  580.         // Get the options as a object for easier handling.
  581.         $options = JArrayHelper::toObject($options);
  582.  
  583.         // Build the path to the sample data file.
  584.         $type = $options->db_type;
  585.  
  586.         if ($type == 'mysqli')
  587.         {
  588.             $type = 'mysql';
  589.         }
  590.         elseif ($type == 'sqlsrv')
  591.         {
  592.             $type = 'sqlazure';
  593.         }
  594.  
  595.         $data = JPATH_INSTALLATION . '/sql/' . $type . '/' . $options->sample_file;
  596.  
  597.         // Attempt to import the database schema if one is chosen.
  598.         if ($options->sample_file != '')
  599.         {
  600.             if (!file_exists($data))
  601.             {
  602.                 $app->enqueueMessage(JText::sprintf('INSTL_DATABASE_FILE_DOES_NOT_EXIST', $data), 'notice');
  603.                 return false;
  604.             }
  605.             elseif (!$this->populateDatabase($db, $data))
  606.             {
  607.                 return false;
  608.             }
  609.  
  610.             $this->postInstallSampleData($db);
  611.         }
  612.  
  613.         return true;
  614.     }
  615.  
  616.     /**
  617.      * Method to update the user id of the sample data content to the new rand user id
  618.      *
  619.      * @param   JDatabaseDriver  $db  Database connector object $db*
  620.      *
  621.      * @return  void 
  622.      *
  623.      * @since   3.1
  624.      */
  625.     protected function postInstallSampleData($db)
  626.     {
  627.         // Create the ID for the root user
  628.         $userId = self::getUserId();
  629.  
  630.         // Update all created_by field of the tables with the random user id
  631.         // categories (created_user_id), contact_details, content, newsfeeds, weblinks
  632.         $updates_array = array(
  633.             'categories' => 'created_user_id',
  634.             'contact_details' => 'created_by',
  635.             'content' => 'created_by',
  636.             'newsfeeds' => 'created_by',
  637.             'weblinks' => 'created_by',
  638.         );
  639.  
  640.         foreach ($updates_array as $table => $field)
  641.         {
  642.             $db->setQuery(
  643.                 'UPDATE ' . $db->quoteName('#__' . $table) .
  644.                     ' SET ' . $db->quoteName($field) . ' = ' . $db->quote($userId)
  645.             );
  646.             $db->execute();
  647.         }
  648.     }
  649.  
  650.     /**
  651.      * Method to backup all tables in a database with a given prefix.
  652.      *
  653.      * @param   JDatabaseDriver  $db      JDatabaseDriver object.
  654.      * @param   string           $prefix  Database table prefix.
  655.      *
  656.      * @return  boolean  True on success.
  657.      *
  658.      * @since    3.1
  659.      */
  660.     public function backupDatabase($db, $prefix)
  661.     {
  662.         $return = true;
  663.         $backup = 'bak_' . $prefix;
  664.  
  665.         // Get the tables in the database.
  666.         $tables = $db->getTableList();
  667.  
  668.         if ($tables)
  669.         {
  670.             foreach ($tables as $table)
  671.             {
  672.                 // If the table uses the given prefix, back it up.
  673.                 if (strpos($table, $prefix) === 0)
  674.                 {
  675.                     // Backup table name.
  676.                     $backupTable = str_replace($prefix, $backup, $table);
  677.  
  678.                     // Drop the backup table.
  679.                     try
  680.                     {
  681.                         $db->dropTable($backupTable, true);
  682.                     }
  683.                     catch (RuntimeException $e)
  684.                     {
  685.                         JFactory::getApplication()->enqueueMessage(JText::sprintf('INSTL_DATABASE_ERROR_BACKINGUP', $e->getMessage()), 'notice');
  686.                         $return = false;
  687.                     }
  688.  
  689.                     // Rename the current table to the backup table.
  690.                     try
  691.                     {
  692.                         $db->renameTable($table, $backupTable, $backup, $prefix);
  693.                     }
  694.                     catch (RuntimeException $e)
  695.                     {
  696.                         JFactory::getApplication()->enqueueMessage(JText::sprintf('INSTL_DATABASE_ERROR_BACKINGUP', $e->getMessage()), 'notice');
  697.                         $return = false;
  698.                     }
  699.                 }
  700.             }
  701.         }
  702.  
  703.         return $return;
  704.     }
  705.  
  706.     /**
  707.      * Method to create a new database.
  708.      *
  709.      * @param   JDatabaseDriver  $db       JDatabase object.
  710.      * @param   JObject          $options  JObject coming from "initialise" function to pass user
  711.      *                                      and database name to database driver.
  712.      * @param   boolean          $utf      True if the database supports the UTF-8 character set.
  713.      *
  714.      * @return  boolean  True on success.
  715.      *
  716.      * @since   3.1
  717.      */
  718.     public function createDB($db, $options, $utf)
  719.     {
  720.         // Build the create database query.
  721.         try
  722.         {
  723.             // Run the create database query.
  724.             $db->createDatabase($options, $utf);
  725.         }
  726.         catch (RuntimeException $e)
  727.         {
  728.             // If an error occurred return false.
  729.             return false;
  730.         }
  731.  
  732.         return true;
  733.     }
  734.  
  735.     /**
  736.      * Method to delete all tables in a database with a given prefix.
  737.      *
  738.      * @param   JDatabaseDriver  $db      JDatabaseDriver object.
  739.      * @param   string           $prefix  Database table prefix.
  740.      *
  741.      * @return  boolean  True on success.
  742.      *
  743.      * @since   3.1
  744.      */
  745.     public function deleteDatabase($db, $prefix)
  746.     {
  747.         $return = true;
  748.  
  749.         // Get the tables in the database.
  750.         $tables = $db->getTableList();
  751.  
  752.         if ($tables)
  753.         {
  754.             foreach ($tables as $table)
  755.             {
  756.                 // If the table uses the given prefix, drop it.
  757.                 if (strpos($table, $prefix) === 0)
  758.                 {
  759.                     // Drop the table.
  760.                     try
  761.                     {
  762.                         $db->dropTable($table);
  763.                     }
  764.                     catch (RuntimeException $e)
  765.                     {
  766.                         JFactory::getApplication()->enqueueMessage(JText::sprintf('INSTL_DATABASE_ERROR_DELETE', $e->getMessage()), 'notice');
  767.                         $return = false;
  768.                     }
  769.                 }
  770.             }
  771.         }
  772.  
  773.         return $return;
  774.     }
  775.  
  776.     /**
  777.      * Method to import a database schema from a file.
  778.      *
  779.      * @param   JDatabaseDriver  $db      JDatabase object.
  780.      * @param   string           $schema  Path to the schema file.
  781.      *
  782.      * @return  boolean  True on success.
  783.      *
  784.      * @since   3.1
  785.      */
  786.     public function populateDatabase($db, $schema)
  787.     {
  788.         // Get the application
  789.         /* @var InstallationApplicationWeb $app */
  790.         $app = JFactory::getApplication();
  791.  
  792.         $return = true;
  793.  
  794.         // Get the contents of the schema file.
  795.         if (!($buffer = file_get_contents($schema)))
  796.         {
  797.             $app->enqueueMessage($db->getErrorMsg(), 'notice');
  798.             return false;
  799.         }
  800.  
  801.         // Get an array of queries from the schema and process them.
  802.         $queries = $this->_splitQueries($buffer);
  803.  
  804.         foreach ($queries as $query)
  805.         {
  806.             // Trim any whitespace.
  807.             $query = trim($query);
  808.  
  809.             // If the query isn't empty and is not a MySQL or PostgreSQL comment, execute it.
  810.             if (!empty($query) && ($query{0} != '#') && ($query{0} != '-'))
  811.             {
  812.                 // Execute the query.
  813.                 $db->setQuery($query);
  814.  
  815.                 try
  816.                 {
  817.                     $db->execute();
  818.                 }
  819.                 catch (RuntimeException $e)
  820.                 {
  821.                     $app->enqueueMessage($e->getMessage(), 'notice');
  822.                     $return = false;
  823.                 }
  824.             }
  825.         }
  826.  
  827.         return $return;
  828.     }
  829.  
  830.     /**
  831.      * Method to set the database character set to UTF-8.
  832.      *
  833.      * @param   JDatabaseDriver  $db    JDatabaseDriver object.
  834.      * @param   string           $name  Name of the database to process.
  835.      *
  836.      * @return  boolean  True on success.
  837.      *
  838.      * @since   3.1
  839.      */
  840.     public function setDatabaseCharset($db, $name)
  841.     {
  842.         // Run the create database query.
  843.         $db->setQuery($db->getAlterDbCharacterSet($name));
  844.  
  845.         try
  846.         {
  847.             $db->execute();
  848.         }
  849.         catch (RuntimeException $e)
  850.         {
  851.             return false;
  852.         }
  853.  
  854.         return true;
  855.     }
  856.  
  857.     /**
  858.      * Method to split up queries from a schema file into an array.
  859.      *
  860.      * @param   string  $query  SQL schema.
  861.      *
  862.      * @return  array  Queries to perform.
  863.      *
  864.      * @since   3.1
  865.      */
  866.     protected function _splitQueries($query)
  867.     {
  868.         $buffer = array();
  869.         $queries = array();
  870.         $in_string = false;
  871.  
  872.         // Trim any whitespace.
  873.         $query = trim($query);
  874.  
  875.         // Remove comment lines.
  876.         $query = preg_replace("/\n\#[^\n]*/", '', "\n" . $query);
  877.  
  878.         // Remove PostgreSQL comment lines.
  879.         $query = preg_replace("/\n\--[^\n]*/", '', "\n" . $query);
  880.  
  881.         // Find function
  882.         $funct = explode('CREATE OR REPLACE FUNCTION', $query);
  883.  
  884.         // Save sql before function and parse it
  885.         $query = $funct[0];
  886.  
  887.         // Parse the schema file to break up queries.
  888.         for ($i = 0; $i < strlen($query) - 1; $i++)
  889.         {
  890.             if ($query[$i] == ";" && !$in_string)
  891.             {
  892.                 $queries[] = substr($query, 0, $i);
  893.                 $query = substr($query, $i + 1);
  894.                 $i = 0;
  895.             }
  896.  
  897.             if ($in_string && ($query[$i] == $in_string) && $buffer[1] != "\\")
  898.             {
  899.                 $in_string = false;
  900.             }
  901.             elseif (!$in_string && ($query[$i] == '"' || $query[$i] == "'") && (!isset ($buffer[0]) || $buffer[0] != "\\"))
  902.             {
  903.                 $in_string = $query[$i];
  904.             }
  905.             if (isset ($buffer[1]))
  906.             {
  907.                 $buffer[0] = $buffer[1];
  908.             }
  909.             $buffer[1] = $query[$i];
  910.         }
  911.  
  912.         // If the is anything left over, add it to the queries.
  913.         if (!empty($query))
  914.         {
  915.             $queries[] = $query;
  916.         }
  917.  
  918.         // Add function part as is
  919.         for ($f = 1; $f < count($funct); $f++)
  920.         {
  921.             $queries[] = 'CREATE OR REPLACE FUNCTION ' . $funct[$f];
  922.         }
  923.  
  924.         return $queries;
  925.     }
  926. }

Documentation generated on Tue, 19 Nov 2013 14:57:50 +0100 by phpDocumentor 1.4.3