core/xpdo/tools/schema/upgrade-mysql-1.1.php
<?php
/*
* Copyright 2010-2015 by MODX, LLC.
*
* This file is part of xPDO.
*
* xPDO 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 2 of the License, or (at your option) any later
* version.
*
* xPDO 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
* xPDO; if not, write to the Free Software Foundation, Inc., 59 Temple Place,
* Suite 330, Boston, MA 02111-1307 USA
*/
/**
* Script that upgrades xPDO mysql models from version 1.0 to the 1.1 format.
*
* Can be run from CLI or web, accepting command-line arguments or $_REQUEST
* variables to set the arguments.
*
* @package xpdo
* @subpackage tools
*/
$scriptTitle = basename(__FILE__, '.php');
/**#@+
* Arguments
*/
/**
* @var string The xPDO root path, where the xpdo.class.php file is located.
*/
$xpdo_path= realpath(dirname(dirname(__DIR__))) . DIRECTORY_SEPARATOR;
/**
* @var string The name of the model package.
*/
$pkg= '';
/**
* @var string The model root path.
*/
$pkg_path= realpath(dirname($xpdo_path) . '/model') . DIRECTORY_SEPARATOR;
/**
* @var string The xPDO model schema filename.
*/
$schema_name= '';
/**
* @var string The path to the model schema file.
*/
$schema_path= realpath(dirname($xpdo_path) . '/schema') . DIRECTORY_SEPARATOR;
/**
* @var string The path to write the backup schema file.
*/
$backup_path= '';
/**
* @var string A string to prepend to the backup file.
*/
$backup_prefix= '~';
/**
* @var string A valid PDO DSN connection string.
*/
$dsn= 'mysql:host=localhost';
/**
* @var string A valid database user name.
*/
$dbuser= 'root';
/**
* @var string The password for the database user.
*/
$dbpass= '';
/**
* @var boolean The debug setting for the script.
*/
$debug= false;
/**
* @var integer The xPDO log level to use. Note 2 is LOG_LEVEL_WARN, 2 is LOG_LEVEL_INFO
*/
$log_level= 2;
/**
* @var integer The PHP error_reporting level to use.
*/
$error_reporting= -1;
/**
* @var boolean Indicates the PHP display_errors setting to use.
*/
$display_errors= true;
/**
* @var boolean If true, will regenerate the model after the schema is updated.
*/
$regen= false;
/**
* @var boolean If true, will write the updated schema changes to file, and backup the original.
*/
$write= false;
/**
* @var boolean If true, will echo the updated schema.
*/
$echo= false;
/**
* @var string An external file to include argument values from; will be overridden
* by CLI or $_REQUEST arguments.
*/
$include= realpath(dirname(__FILE__) . DIRECTORY_SEPARATOR . "{$scriptTitle}.properties");
$defaultInclude= true;
$properties= array();
if (!empty($argv) && $argc > 1) {
/* process CLI arguments */
reset($argv);
while ($argument = next($argv)) {
if (strpos($argument, '=') > 0) {
$arg = explode('=', $argument);
$argKey = trim($arg[0], '-');
$argValue = trim($arg[1], '"');
if (strpos($argKey, '_path') > 0) {
$argValue = realpath($argValue) . DIRECTORY_SEPARATOR;
}
if ($argKey == 'include') {
$argValue = realpath($argValue);
$defaultInclude= false;
}
$properties[$argKey] = $argValue;
} else {
$properties[trim($argument, '-')] = true;
}
}
} elseif (!empty($_REQUEST)) {
/* process $_REQUEST arguments */
foreach ($_REQUEST as $argKey => $argValue) {
if (in_array(strtolower($argValue), array('true','false'))) {
$argValue = $argValue === 'true' ? true : false;
}
if (strpos($argKey, '_path') > 0) {
$argValue = realpath($argValue) . DIRECTORY_SEPARATOR;
}
if ($argKey == 'include') {
$argValue = realpath($argValue);
$defaultInclude= false;
}
$properties[$argKey] = $argValue;
}
}
/* load external properties from default or specified file */
if (!empty($include) && file_exists($include)) {
if (!include ($include)) {
die("[{$scriptTitle}] FATAL: Error loading " . ($defaultInclude ? " default " : "") . "external properties file --include={$include}.\n");
}
} elseif (!empty($include) && !$defaultInclude) {
die("[{$scriptTitle}] FATAL: External properties file not found --include={$include}.\n");
}
extract($properties, EXTR_OVERWRITE);
if (empty($pkg)) {
die("[{$scriptTitle}] FATAL: No valid pkg was specified.\n");
}
if (empty($pkg_path)) {
die("[{$scriptTitle}] FATAL: No pkg_path was specified.\n");
}
if (empty($schema_name)) {
die("[{$scriptTitle}] FATAL: No schema_name was specified.\n");
}
if (empty($schema_path)) {
die("[{$scriptTitle}] FATAL: No schema_path was specified.\n");
}
if (empty($echo) && empty($write) && empty($regen) && $debug !== true) {
die("[{$scriptTitle}] FATAL: At least one of the options --echo, --write, --regen, or --debug must be set.\n");
}
if ($debug === true && !empty($write)) {
die("[{$scriptTitle}] FATAL: --write cannot be used when --debug is set.\n");
}
if (!file_exists("{$xpdo_path}xpdo.class.php")) {
die("[{$scriptTitle}] FATAL: xPDO class not found; invalid xpdo_path: {$xpdo_path}.\n");
}
include_once ("{$xpdo_path}xpdo.class.php");
$xpdo= new xPDO($dsn, $dbuser, $dbpass);
if (!is_object($xpdo)) {
die("[{$scriptTitle}] FATAL: Error getting instance of xPDO object.");
}
$xpdo->setLogTarget(XPDO_CLI_MODE ? 'ECHO' : 'HTML');
$xpdo->setLogLevel($log_level);
if (!empty($debug)) {
if ($debug === true && empty($echo)) {
$echo = true;
}
$xpdo->setDebug($debug);
}
error_reporting($error_reporting);
ini_set('display_errors', (boolean) $display_errors);
$xpdo->setPackage($pkg, $pkg_path);
$xpdo->getCacheManager();
if (!file_exists("{$schema_path}{$schema_name}")) {
$xpdo->log(xPDO::LOG_LEVEL_FATAL, "Could not find schema: {$schema_path}{$schema_file}");
}
/* load the schema file as a DOMDocument */
$schema = new DOMDocument();
$loaded = $schema->load("{$schema_path}{$schema_name}");
if ($loaded === false) {
$xpdo->log(xPDO::LOG_LEVEL_FATAL, "Error loading schema file: {$schema_path}{$schema_file}");
}
$schema->formatOutput = true;
if (!empty($write)) {
/* backup the existing schema if the --write argument is set */
$backupSchemaName = $backup_prefix . $schema_name;
if (empty($backup_path)) $backup_path = $schema_path;
if ($backupSchemaName === $schema_name && $backup_path === $schema_path) {
$xpdo->log(xPDO::LOG_LEVEL_FATAL, "backup_prefix is empty and no backup_path was specified.");
}
if (!$xpdo->cacheManager->writeFile("{$backup_path}{$backupSchemaName}", $schema->saveXML())) {
$xpdo->log(xPDO::LOG_LEVEL_FATAL, "Error backing up schema to {$backup_path}{$backupSchemaName}.");
}
}
/* parse the schema's DOM */
$rootIdx = 0;
$root = $schema->documentElement;
$xpdo->log(xPDO::LOG_LEVEL_INFO, "parsing root element: {$root->nodeName}");
if (strtolower($root->nodeName) !== 'model') {
$xpdo->log(xPDO::LOG_LEVEL_FATAL, "root element is not a valid model schema element: {$root->nodeName}");
}
$platform = $root->attributes->getNamedItem('platform');
if (strtolower($platform->nodeValue) !== 'mysql') {
$xpdo->log(xPDO::LOG_LEVEL_FATAL, "this model is not a mysql model; this migration is not intended for {$platform->nodeValue}");
}
$written = false;
if ($root->hasAttribute('version')) {
$version = $root->attributes->getNamedItem('version');
if ($written = version_compare($version->nodeValue, '1.1', '>=')) {
if (!empty($write) || empty($regen)) {
$xpdo->log(xPDO::LOG_LEVEL_FATAL, "this model is already at version 1.1; this migration is intended for older models");
}
}
}
if (!empty($regen) && empty($write) && empty($written)) {
die("[{$scriptTitle}] FATAL: --regen can only be used when --write is set or the schema is already at version 1.1.\n");
}
if (empty($written)) {
$root->setAttribute('version', '1.1');
$attrs = array();
$attrIdx = 0;
while ($attr = $root->attributes->item($attrIdx++)) $attrs[$attr->nodeName] = $attr->nodeValue;
$xpdo->log(xPDO::LOG_LEVEL_INFO, "model element ({$rootIdx}): " . print_r($attrs, true));
$objectIdx = 0;
while ($object = $root->childNodes->item($objectIdx++)) {
$xpdo->log(xPDO::LOG_LEVEL_DEBUG, "parsing model child element: {$object->nodeName}");
if (strtolower($object->nodeName !== 'object')) continue;
$attrs = array();
$attrIdx = 0;
while ($attr = $object->attributes->item($attrIdx++)) $attrs[$attr->nodeName] = $attr->nodeValue;
$xpdo->log(xPDO::LOG_LEVEL_INFO, "object element ({$objectIdx}): " . print_r($attrs, true));
$indexes = array();
$idx = 0;
while ($node = $object->childNodes->item($idx++)) {
$xpdo->log(xPDO::LOG_LEVEL_DEBUG, "parsing object child element: {$node->nodeName}");
if (strtolower($node->nodeName !== 'field')) continue;
$attrs = array();
$attrIdx = 0;
while ($attr = $node->attributes->item($attrIdx++)) $attrs[$attr->nodeName] = $attr->nodeValue;
$xpdo->log(xPDO::LOG_LEVEL_INFO, "field element ({$idx}): " . print_r($attrs, true));
if (!isset($attrs['key']) || empty($attrs['key'])) {
$xpdo->log(xPDO::LOG_LEVEL_ERROR, "Skipping field element: no valid key attribute");
continue;
}
$groupMember = false;
$fieldKey = $attrs['key'];
if (!isset($attrs['index']) || empty($attrs['index'])) {
$xpdo->log(xPDO::LOG_LEVEL_INFO, "Skipping field element: no index attribute");
continue;
}
$fieldIndex = $attrs['index'];
$fieldNull = isset($attrs['null']) ? $attrs['null'] : 'true';
$indexName = isset($attrs['indexgrp']) && !empty($attrs['indexgrp']) ? $attrs['indexgrp'] : $fieldKey;
$indexColumn = $fieldKey;
$indexColumnLength = '';
$indexColumnCollation = 'A';
$indexColumnNull = !empty($fieldNull) ? $fieldNull : 'true';
$indexPrimary = 'false';
$indexUnique = 'false';
$indexType = 'BTREE';
switch ($fieldIndex) {
case 'pk':
$indexName = 'PRIMARY';
$indexPrimary = true;
$indexUnique = true;
break;
case 'unique':
$indexUnique = true;
break;
case 'fulltext':
$indexType = 'FULLTEXT';
break;
case 'fk':
case 'index':
default:
break;
}
if (!isset($indexes[$indexName])) {
$indexes[$indexName] = array(
'attributes' => array(
'name' => $indexName,
'alias' => $indexName,
'primary' => $indexPrimary,
'unique' => $indexUnique,
'type' => $indexType
),
'columns' => array(
$indexColumn => array(
'key' => $indexColumn,
'length' => $indexColumnLength,
'collation' => $indexColumnCollation,
'null' => $indexColumnNull
)
)
);
} else {
$indexes[$indexName]['columns'][$indexColumn] = array(
'key' => $indexColumn,
'length' => $indexColumnLength,
'collation' => $indexColumnCollation,
'null' => $indexColumnNull
);
}
}
if (!empty($indexes)) {
$xpdo->log(xPDO::LOG_LEVEL_INFO, "Generating XML for index elements: " . print_r($indexes, true));
$fragment = $schema->createDocumentFragment();
$fragment->appendChild($schema->createTextNode("\n "));
$fragment->appendChild($schema->createComment("Element indexes automatically generated by script: {$scriptTitle}"));
$fragment->appendChild($schema->createTextNode("\n"));
foreach ($indexes as $indexName => $index) {
$indexElement = $schema->createElement('index');
$indexElement->appendChild($schema->createTextNode("\n "));
foreach ($index['attributes'] as $attrKey => $attrVal) {
$indexElement->setAttribute($attrKey, $attrVal);
}
foreach ($index['columns'] as $columnKey => $column) {
$columnElement = $schema->createElement('column');
foreach ($column as $colAttrKey => $colAttrVal) {
$columnElement->setAttribute($colAttrKey, $colAttrVal);
}
$indexElement->appendChild($schema->createTextNode(" "));
$indexElement->appendChild($columnElement);
$indexElement->appendChild($schema->createTextNode("\n "));
}
$fragment->appendChild($schema->createTextNode(" "));
$fragment->appendChild($indexElement);
$fragment->appendChild($schema->createTextNode("\n"));
}
$fragment->appendChild($schema->createTextNode("\n "));
$indexElementNode = $schema->importNode($fragment, true);
$object->appendChild($indexElementNode);
}
}
}
$xml = $schema->saveXML();
if (!empty($echo)) {
echo (XPDO_CLI_MODE ? "{$schema_name}:\n{$xml}\n" : "<h1>{$schema_name}</h1>\n<pre>{$xml}</pre>\n<br />");
}
if (!empty($write) && empty($written)) {
$xpdo->log(xPDO::LOG_LEVEL_INFO, "Updating schema file at {$schema_path}{$schema_name}...");
if (!$xpdo->cacheManager->writeFile("{$schema_path}{$schema_name}", $xml)) {
$xpdo->log(xPDO::LOG_LEVEL_FATAL, "Migration failed! Error writing content to file at {$schema_path}{$schema_name}");
}
$xpdo->log(xPDO::LOG_LEVEL_INFO, "Migration of schema file {$schema_name} for pkg {$pkg} completed successfully.");
}
if ((!empty($write) || !empty($written)) && !empty($regen)) {
$xpdo->log(xPDO::LOG_LEVEL_INFO, "Attempting to regenerate model maps for pkg {$pkg} from migrated schema at {$pkg_path}...");
if (!$xpdo->getManager() || !$xpdo->manager->getGenerator()) {
$xpdo->log(xPDO::LOG_LEVEL_FATAL, "Model regeneration failed: could not get instance of the xPDOManager or xPDOGenerator.");
}
if (!$xpdo->manager->generator->parseSchema("{$schema_path}{$schema_name}", $pkg_path)) {
$xpdo->log(xPDO::LOG_LEVEL_FATAL, "Model regeneration failed! Error parsing schema {$schema_name} for pkg {$pkg} at {$pkg_path}.");
}
$xpdo->log(xPDO::LOG_LEVEL_INFO, "Regeneration of model files for pkg {$pkg} at {$pkg_path} completed successfully.");
}
exit();