Source for file changeset.php

Documentation is available at changeset.php

  1. <?php
  2. /**
  3.  * @package     Joomla.Libraries
  4.  * @subpackage  Schema
  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
  8.  */
  9.  
  10. defined('JPATH_PLATFORM') or die;
  11.  
  12. jimport('joomla.filesystem.folder');
  13.  
  14. /**
  15.  * Contains a set of JSchemaChange objects for a particular instance of Joomla.
  16.  * Each of these objects contains a DDL query that should have been run against
  17.  * the database when this database was created or updated. This enables the
  18.  * Installation Manager to check that the current database schema is up to date.
  19.  *
  20.  * @package     Joomla.Libraries
  21.  * @subpackage  Schema
  22.  * @since       2.5
  23.  */
  24. class JSchemaChangeset
  25. {
  26.     /**
  27.      * Array of JSchemaChangeitem objects
  28.      *
  29.      * @var    array 
  30.      * @since  2.5
  31.      */
  32.     protected $changeItems = array();
  33.  
  34.     /**
  35.      * JDatabaseDriver object
  36.      *
  37.      * @var    JDatabaseDriver 
  38.      * @since  2.5
  39.      */
  40.     protected $db = null;
  41.  
  42.     /**
  43.      * Folder where SQL update files will be found
  44.      *
  45.      * @var    string 
  46.      */
  47.     protected $folder = null;
  48.  
  49.     /**
  50.      * Constructor: builds array of $changeItems by processing the .sql files in a folder.
  51.      * The folder for the Joomla core updates is administrator/components/com_admin/sql/updates/<database>.
  52.      *
  53.      * @param   JDatabaseDriver  $db      The current database object
  54.      * @param   string           $folder  The full path to the folder containing the update queries
  55.      *
  56.      * @since   2.5
  57.      */
  58.     public function __construct($db, $folder = null)
  59.     {
  60.         $this->db = $db;
  61.         $this->folder = $folder;
  62.         $updateFiles = $this->getUpdateFiles();
  63.         $updateQueries = $this->getUpdateQueries($updateFiles);
  64.         foreach ($updateQueries as $obj)
  65.         {
  66.             $this->changeItems[] = JSchemaChangeitem::getInstance($db, $obj->file, $obj->updateQuery);
  67.         }
  68.     }
  69.  
  70.     /**
  71.      * Returns a reference to the JSchemaChangeset object, only creating it if it doesn't already exist.
  72.      *
  73.      * @param   JDatabaseDriver  $db      The current database object
  74.      * @param   string           $folder  The full path to the folder containing the update queries
  75.      *
  76.      * @return  JSchemaChangeset 
  77.      *
  78.      * @since   2.5
  79.      */
  80.     public static function getInstance($db, $folder)
  81.     {
  82.         static $instance;
  83.  
  84.         if (!is_object($instance))
  85.         {
  86.             $instance = new JSchemaChangeset($db, $folder);
  87.         }
  88.  
  89.         return $instance;
  90.     }
  91.  
  92.     /**
  93.      * Checks the database and returns an array of any errors found.
  94.      * Note these are not database errors but rather situations where
  95.      * the current schema is not up to date.
  96.      *
  97.      * @return   array Array of errors if any.
  98.      *
  99.      * @since    2.5
  100.      */
  101.     public function check()
  102.     {
  103.         $errors = array();
  104.         foreach ($this->changeItems as $item)
  105.         {
  106.             if ($item->check() === -2)
  107.             {
  108.                 // Error found
  109.                 $errors[] = $item;
  110.             }
  111.         }
  112.         return $errors;
  113.     }
  114.  
  115.     /**
  116.      * Runs the update query to apply the change to the database
  117.      *
  118.      * @return  void 
  119.      *
  120.      * @since   2.5
  121.      */
  122.     public function fix()
  123.     {
  124.         $this->check();
  125.         foreach ($this->changeItems as $item)
  126.         {
  127.             $item->fix();
  128.         }
  129.     }
  130.  
  131.     /**
  132.     * Returns an array of results for this set
  133.     *
  134.     * @return  array  associative array of changeitems grouped by unchecked, ok, error, and skipped
  135.     *
  136.     * @since   2.5
  137.     */
  138.     public function getStatus()
  139.     {
  140.         $result = array('unchecked' => array(), 'ok' => array(), 'error' => array(), 'skipped' => array());
  141.         foreach ($this->changeItems as $item)
  142.         {
  143.             switch ($item->checkStatus)
  144.             {
  145.                 case 0:
  146.                     $result['unchecked'][] = $item;
  147.                     break;
  148.                 case 1:
  149.                     $result['ok'][] = $item;
  150.                     break;
  151.                 case -2:
  152.                     $result['error'][] = $item;
  153.                     break;
  154.                 case -1:
  155.                     $result['skipped'][] = $item;
  156.                     break;
  157.             }
  158.         }
  159.         return $result;
  160.     }
  161.  
  162.     /**
  163.      * Gets the current database schema, based on the highest version number.
  164.      * Note that the .sql files are named based on the version and date, so
  165.      * the file name of the last file should match the database schema version
  166.      * in the #__schemas table.
  167.      *
  168.      * @return  string  the schema version for the database
  169.      *
  170.      * @since   2.5
  171.      */
  172.     public function getSchema()
  173.     {
  174.         $updateFiles = $this->getUpdateFiles();
  175.         $result = new SplFileInfo(array_pop($updateFiles));
  176.         return $result->getBasename('.sql');
  177.     }
  178.  
  179.     /**
  180.      * Get list of SQL update files for this database
  181.      *
  182.      * @return  array  list of sql update full-path names
  183.      *
  184.      * @since   2.5
  185.      */
  186.     private function getUpdateFiles()
  187.     {
  188.         // Get the folder from the database name
  189.         $sqlFolder = $this->db->name;
  190.  
  191.         if ($sqlFolder == 'mysqli')
  192.         {
  193.             $sqlFolder = 'mysql';
  194.         }
  195.         elseif ($sqlFolder == 'sqlsrv')
  196.         {
  197.             $sqlFolder = 'sqlazure';
  198.         }
  199.  
  200.         // Default folder to core com_admin
  201.         if (!$this->folder)
  202.         {
  203.             $this->folder = JPATH_ADMINISTRATOR . '/components/com_admin/sql/updates/';
  204.         }
  205.  
  206.         return JFolder::files(
  207.             $this->folder . '/' . $sqlFolder, '\.sql$', 1, true, array('.svn', 'CVS', '.DS_Store', '__MACOSX'), array('^\..*', '.*~'), true
  208.         );
  209.     }
  210.  
  211.     /**
  212.      * Get array of SQL queries
  213.      *
  214.      * @param   array  $sqlfiles  Array of .sql update filenames.
  215.      *
  216.      * @return  array  Array of stdClass objects where:
  217.      *                     file=filename,
  218.      *                     update_query = text of SQL update query
  219.      *
  220.      * @since   2.5
  221.      */
  222.     private function getUpdateQueries(array $sqlfiles)
  223.     {
  224.         // Hold results as array of objects
  225.         $result = array();
  226.         foreach ($sqlfiles as $file)
  227.         {
  228.             $buffer = file_get_contents($file);
  229.  
  230.             // Create an array of queries from the sql file
  231.             $queries = JDatabaseDriver::splitSql($buffer);
  232.             foreach ($queries as $query)
  233.             {
  234.                 if ($trimmedQuery = $this->trimQuery($query))
  235.                 {
  236.                     $fileQueries = new stdClass;
  237.                     $fileQueries->file = $file;
  238.                     $fileQueries->updateQuery = $trimmedQuery;
  239.                     $result[] = $fileQueries;
  240.                 }
  241.             }
  242.         }
  243.         return $result;
  244.     }
  245.  
  246.     /**
  247.      * Trim comment and blank lines out of a query string
  248.      *
  249.      * @param   string  $query  query string to be trimmed
  250.      *
  251.      * @return  string  String with leading comment lines removed
  252.      *
  253.      * @since   3.1
  254.      */
  255.     private function trimQuery($query)
  256.     {
  257.         $query = trim($query);
  258.  
  259.         while (substr($query, 0, 1) == '#' || substr($query, 0, 2) == '--' || substr($query, 0, 2) == '/*')
  260.         {
  261.             $endChars = (substr($query, 0, 1) == '#' || substr($query, 0, 2) == '--') ? "\n" : "*/";
  262.  
  263.             if ($position = strpos($query, $endChars))
  264.             {
  265.                 $query = trim(substr($query, $position + strlen($endChars)));
  266.             }
  267.             else
  268.             {
  269.                 // If no newline, the rest of the file is a comment, so return an empty string.
  270.                 return '';
  271.             }
  272.         }
  273.  
  274.         return trim($query);
  275.     }
  276. }

Documentation generated on Tue, 19 Nov 2013 14:55:39 +0100 by phpDocumentor 1.4.3