开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 网络 > 查看源码
cb.sql.upgrader.php
资源名称：com_comprofiler.zip　[点击查看]
上传用户：stephen_wu
上传日期：2008-07-05
资源大小：1757k
文件大小：74k
源码类别：

网络

开发平台：

Unix_Linux

cb.sql.upgrader.php：源码内容
  1. <?php
  2. /**
  3. * @version $Id: cb.sql.upgrader.php 444 2008-03-05 02:25:39Z beat $
  4. * @package Community Builder
  5. * @subpackage cb.sql.upgrader.php
  6. * @author Beat
  7. * @copyright (C) 2007 Beat and Lightning MultiCom SA, 1009 Pully, Switzerland
  8. * @license Lightning Proprietary. See licence. Allowed for free use within CB and for CB plugins.
  9. */
  11. // no direct access
  12. if ( ! ( defined( '_VALID_CB' ) || defined( '_JEXEC' ) || defined( '_VALID_MOS' ) ) ) { die( 'Direct Access to this location is not allowed.' ); }
  14. // cbimport('cb.xml.simplexml'); needed to use this.
  16. /**
  17.  * CB SQL versioning / upgrading functions:
  18.  * 
  19.  * WARNING:
  20.  * This new library is experimental work in progress and should not be used directly by plugins and 3pds,
  21.  * as it is subject to change without notice, and is not part of current CB API.
  22.  * 
  23.  * @access private
  24.  * 
  25.  */
  26. class CBSQLupgrader {
  27. /** Database
  28.  * @var CBdatabase */
  29. var $_db = null;
  30. var $_silentTestLogs = true;
  31. var $_logs = array();
  32. var $_errors = array();
  33. var $_logsIndex = 0;
  34. var $_dryRun = false;
  35. /**
  36.  * Constructor
  37.  *
  38.  * @param  CBdatabase     $db
  39.  * @param  boolean        $silentTestLogs  TRUE: Silent on successful tests
  40.  * @return CBSQLupgrader
  41.  */
  42. function CBSQLupgrader( &$db, $silentTestLogs = true ) {
  43. $this->_db =& $db;
  44. $this->_silentTestLogs = $silentTestLogs;
  45. }
  46. /**
  47.  * Sets if SQL tables changing queries should not be run (for a dryrun)
  48.  *
  49.  * @param  boolean  $dryRun  FALSE (default): tables are changed, TRUE: Dryrunning
  50.  */
  51. function setDryRun( $dryRun ) {
  52. $this->_dryRun = $dryRun;
  53. }
  54. /**
  55.  * LOGS OF ACTIONS AND OF ERRORS:
  56.  */
  57. /**
  58.  * Records error with details (details here is SQL query)
  59.  * @access private
  60.  *
  61.  * @param  string  $error
  62.  * @param  string  $info
  63.  */
  64. function _setError( $error, $info = null) {
  65. $this->_errors[++$this->_logsIndex] = array( $error, $info );
  66. }
  67. /**
  68.  * Returns all errors logged
  69.  *
  70.  * @param  string|boolean  $implode         False: returns full array, if string: imploding string
  71.  * @param  string|boolean  $detailsImplode  False: no details, otherwise imploding string
  72.  * @return string|array
  73.  */
  74. function getErrors( $implode = "n", $detailsImplode = false ) {
  75. if ( $implode === false) {
  76. return $this->_errors;
  77. } else {
  78. $errors = array();
  79. if ( $detailsImplode ) {
  80. foreach ( $this->_errors as $errInfo ) {
  81. $errors[] = implode( $detailsImplode, $errInfo );
  82. }
  83. } else {
  84. foreach ( $this->_errors as $errInfo ) {
  85. $errors[] = $errInfo[0];
  86. }
  87. }
  88. return implode( $implode, $errors );
  89. }
  90. }
  91. /**
  92.  * Records logs with details (details here are SQL queries ( ";n"-separated )
  93.  * @access private
  94.  *
  95.  * @param  string  $log
  96.  * @param  string  $info
  97.  * @param  string  $type  'ok': successful check, 'change': successful change
  98.  */
  99. function _setLog( $log, $info = null, $type ) {
  100. if ( ( $type != 'ok' ) || ! $this->_silentTestLogs ) {
  101. $this->_logs[++$this->_logsIndex] = array( $log, $info );
  102. }
  103. }
  104. /**
  105.  * Returns all logs logged
  106.  *
  107.  * @param  string|boolean  $implode         False: returns full array, if string: imploding string
  108.  * @param  string|boolean  $detailsImplode  False: no details, otherwise imploding string
  109.  * @return string|array
  110.  */
  111. function getLogs( $implode = "n", $detailsImplode = false ) {
  112. if ( $implode === false) {
  113. return $this->_logs;
  114. } else {
  115. $logs = array();
  116. if ( $detailsImplode ) {
  117. foreach ( $this->_logs as $logInfo ) {
  118. $logs[] = implode( $detailsImplode, $logInfo );
  119. }
  120. } else {
  121. foreach ( $this->_logs as $logInfo ) {
  122. $logs[] = $logInfo[0];
  123. }
  124. }
  125. return implode( $implode, $logs );
  126. }
  127. }
  129. /**
  130.  * SQL ACCESS FUNCTIONS:
  131.  */
  133. /**
  134.  * Checks if a given table exists in the database
  135.  * @access private
  136.  *
  137.  * @param  string  $tableName  Name of table
  138.  * @return boolean
  139.  */
  140. function checkTableExists( $tableName ) {
  141. $allTables = $this->_db->getTableList();
  142. return ( in_array( $tableName, $allTables ) );
  143. }
  144. /**
  145.  * Checks if table exists in database and returns all fields of table.
  146.  * Otherwise returns boolean false.
  147.  * @access private
  148.  *
  149.  * @param  string  $tableName  Name of table
  150.  * @return array|boolean       Array of SHOW COLUMNS FROM ... in SQL or boolean FALSE
  151.  */
  152. function getAllTableColumns( $tableName ) {
  153. if ( $this->checkTableExists( $tableName ) ) {
  154. $fields = $this->_db->getTableFields( $tableName, false );
  155. if ( isset( $fields[$tableName] ) ) {
  156. return $fields[$tableName];
  157. }
  158. }
  159. return false;
  160. }
  161. /**
  162.  * Returns all indexes of the table
  163.  * @access private
  164.  *
  165.  * @param  string  $tableName  Name of table
  166.  * @return array               Array of SHOW INDEX FROM ... in SQL
  167.  */
  168. function getAllTableIndexes( $tableName ) {
  169. $sortedIndex = array();
  170. $idx = $this->_db->getTableIndex( $tableName );
  171. if ( is_array( $idx ) ) {
  172. foreach ( $idx as $k => $n ) {
  173. $sortedIndex[$n->Key_name][$n->Seq_in_index] = array( 'name' => $n->Column_name,
  174. 'size' => $n->Sub_part,
  175. 'ordering' => $n->Collation,
  177. 'type' => ( $n->Key_name == 'PRIMARY' ? 'primary' : ( $n->Non_unique == 0 ? 'unique' : '' ) ),
  178. 'using' => ( array_key_exists( 'Index_type', $n ) ? strtolower( $n->Index_type ) : ( $n->Comment == 'FULLTEXT' ? 'fulltext' : '' ) ) // mysql <4.0.2 support
  179.  );
  180. }
  181. }
  182. return $sortedIndex;
  183. }
  185. /**
  186.  * COLUMNS CHECKS:
  187.  */
  189. /**
  190.  * Checks if a column exists and has the type of the parameters below:
  191.  * @access private
  192.  *
  193.  * @param  string              $tableName        Name of table (for error strings)
  194.  * @param  array               $allColumns       From $this->getAllTableColumns( $table )
  195.  * @param  CBSimpleXMLElement  $column           Column to check
  196.  * @param  string              $colNamePrefix    Prefix to add to all column names
  197.  * @param  boolean             $change           TRUE: only true/false check type, FALSE: logs success and if mismatch, error details
  198.  * @return boolean             TRUE: identical (no check on indexes), FALSE: errors are in $this->getErrors()
  199.  */
  200. function checkColumnExistsType( $tableName, &$allColumns, &$column, $colNamePrefix, $change ) {
  201. $colName = $this->_prefixedName( $column, $colNamePrefix );
  202. if ( isset( $allColumns[$colName] ) ) {
  203. if ( ! cbStartOfStringMatch( $column->attributes( 'type' ), 'sql:' ) ) {
  204. $this->_setError( sprintf( 'Table %s Column %s type is %s instead of being prefixed by "sql:"', $tableName, $colName, $column->attributes( 'type' ) ) );
  205. return false;
  206. }
  207. if ( $column->attributes( 'strict' ) === 'false' ) {
  208. $this->_setLog( sprintf( 'Table %s Column %s exists but is not of strict type, so not checked.', $tableName, $colName ), null, 'ok' );
  209. return true;
  210. }
  211. $type = substr( $column->attributes( 'type' ), 4 );
  212. $shouldbeType = $type . ( $column->attributes( 'unsigned' ) === 'true' ? ' unsigned' : '' );
  213. if ( $allColumns[$colName]->Type !== $shouldbeType ) {
  214. if ( $change === false ) {
  215. $this->_setError( sprintf( 'Table %s Column %s type is %s instead of %s', $tableName, $colName, $allColumns[$colName]->Type, $shouldbeType ) );
  216. }
  217. return false;
  218. }
  219. if ( ( $column->attributes( 'null' ) === 'true' ) !== ( $allColumns[$colName]->Null == 'YES' ) ) { //if ( $column->attributes( 'null' ) !== null ): no attribute NULL means NOT NULL
  220. if ( $change === false ) {
  221. $this->_setError( sprintf( 'Table %s Column %s NULL attribute is %s instead of %s', $tableName, $colName, $allColumns[$colName]->Null, ( $column->attributes( 'null' ) === 'true' ? 'YES' : 'NO') ) );
  222. }
  223. return false;
  224. }
  226. // BLOB and TEXT columns cannot have DEFAULT values. http://dev.mysql.com/doc/refman/5.0/en/blob.html
  227. $defaultValuePossible = ! in_array( $type, array( 'text', 'blob', 'tinytext', 'mediumtext', 'longtext', 'tinyblob', 'mediumblob', 'longblob' ) );
  228. // autoincremented columns don't care for default values:
  229. $autoIncrementedColumn = ! in_array( $column->attributes( 'auto_increment' ), array( null, '', 'false' ), true );
  231. if ( $defaultValuePossible && ! $autoIncrementedColumn ) {
  232. if ( $column->attributes( 'default' ) === null ) {
  233. if ( $column->attributes( 'null' ) === 'true' ) {
  234. $shouldbeDefault = array( null );
  235. } else {
  236. $shouldbeDefault = $this->defaultValuesOfTypes( $this->mysqlToXmlsql( $column->attributes( 'type' ) ) );
  237. }
  238. } else {
  239. $shouldbeDefault = ( $column->attributes( 'default' ) === 'NULL' ? array( null ) : array( $column->attributes( 'default' ) ) );
  240. }
  241. if ( ! in_array( $allColumns[$colName]->Default, $shouldbeDefault, true ) ) {
  242. if ( $change === false ) {
  243. $this->_setError( sprintf( 'Table %s Column %s DEFAULT is %s instead of %s', $tableName, $colName, $this->displayNull( $allColumns[$colName]->Default ), $column->attributes( 'default' ) ) );
  244. }
  245. return false;
  246. }
  247. }
  248. $shouldbeExtra = ( $autoIncrementedColumn ? 'auto_increment' : '' );
  249. if ( $allColumns[$colName]->Extra !== $shouldbeExtra ) {
  250. if ( $change === false ) {
  251. $this->_setError( sprintf( 'Table %s Column %s AUTO_INCREMENT attribute is "%s" instead of "%s"', $tableName, $colName, $allColumns[$colName]->Extra, $shouldbeExtra ) );
  252. }
  253. return false;
  254. }
  255. $this->_setLog( sprintf( 'Table %s Column %s structure is up-to-date.', $tableName, $colName ), null, 'ok' );
  256. return true;
  257. }
  258. if ( $change === false ) {
  259. $this->_setError( sprintf( 'Table %s Column %s does not exist', $tableName, $colName ), null );
  260. }
  261. return false;
  262. }
  263. /**
  264.  * Utility to display NULL for nulls and quotations.
  265.  *
  266.  * @param unknown_type $val
  267.  * @return unknown
  268.  */
  269. function displayNull( $val ) {
  270. if ( $val === null ) {
  271. return 'NULL';
  272. } elseif ( is_numeric( $val ) ) {
  273. return $val;
  274. } else {
  275. return "'" . $val . "'";
  276. }
  277. }
  278. /**
  279.  * Checks if a column exists and has the type of the parameters below:
  280.  * @access private
  281.  *
  282.  * @param  string              $tableName       Name of table (for error strings)
  283.  * @param  array               $allColumns      From $this->getAllTableColumns( $table )
  284.  * @param  CBSimpleXMLElement  $columns         Columns to check array of string  Name of columns which are allowed to (should) exist
  285.  * @param  string              $colNamePrefix    Prefix to add to all column names
  286.  * @param  boolean             $drop            TRUE If drops unneeded columns or not
  287.  * @return boolean             TRUE: no other columns exist, FALSE: errors are in $this->getErrors()
  288.  */
  289. function checkOtherColumnsExist( $tableName, &$allColumns, &$columns, $colNamePrefix, $drop = false ) {
  290. $isMatching = false;
  291. if ( $columns->name() == 'columns' ) {
  292. $isMatching = true;
  293. foreach ( array_keys( $allColumns ) as $existingColumnName ) {
  294. if ( ! $this->_inXmlChildrenAttribute( $existingColumnName, $columns, 'column', 'name', $colNamePrefix ) ) {
  295. if ( $drop ) {
  296. if ( ! $this->dropColumn( $tableName, $existingColumnName ) ) {
  297. $isMatching = false;
  298. }
  299. } else {
  300. $isMatching = false;
  301. $this->_setError( sprintf( 'Table %s Column %s exists but should not exist', $tableName, $existingColumnName ), null );
  302. }
  303. }
  304. }
  305. if ( $isMatching && ! $drop ) {
  306. $this->_setLog( sprintf( 'Table %s has no unneeded columns.', $tableName ), null, 'ok' );
  307. }
  308. }
  309. return $isMatching;
  310. }
  312. /**
  313.  * INDEXES CHECKS:
  314.  */
  316. /**
  317.  * Checks if an index exists and has the type of the parameters below:
  318.  * @access private
  319.  *
  320.  * @param  string              $tableName        Name of table (for error strings)
  321.  * @param  array               $allIndexes       From $this->getAllTableIndexes( $table )
  322.  * @param  CBSimpleXMLElement  $index            Index to check
  323.  * @param  string              $colNamePrefix    Prefix to add to all column names
  324.  * @param  boolean             $change           TRUE: only true/false check type, FALSE: logs success and if mismatch, error details
  325.  * @return boolean             TRUE: identical, FALSE: errors are in $this->getErrors()
  326.  */
  327. function checkIndexExistsType( $tableName, &$allIndexes, &$index, $colNamePrefix, $change ) {
  328. $indexName = $this->_prefixedName( $index, $colNamePrefix );
  329. if ( isset( $allIndexes[$indexName] ) && isset( $allIndexes[$indexName][1] ) ) {
  330. $idxType = $allIndexes[$indexName][1]['type'];
  331. $idxUsing = $allIndexes[$indexName][1]['using'];
  333. if ( $idxType != $index->attributes( 'type' ) ) {
  334. if ( $change === false ) {
  335. $this->_setError( sprintf( 'Table %s Index %s type is %s instead of %s', $tableName, $indexName, $idxType, $index->attributes( 'type' ) ) );
  336. }
  337. return false;
  338. }
  339. if ( $index->attributes( 'using' ) && ( $idxUsing != $index->attributes( 'using' ) ) ) {
  340. if ( $change === false ) {
  341. $indexShouldBeUsing = ( $index->attributes( 'using' ) ? $index->attributes( 'using' ) : 'btree' );
  342. $this->_setError( sprintf( 'Table %s Index %s is using %s instead of %s', $tableName, $indexName, $idxUsing, $indexShouldBeUsing ) );
  343. }
  344. return false;
  345. }
  346. $sequence = 1;
  347. foreach ( $index->children() as $column ) {
  348. if ( $column->name() == 'column' ) {
  349. $colName = $this->_prefixedName( $column, $colNamePrefix );
  350. if ( ! isset( $allIndexes[$indexName][$sequence] ) ) {
  351. if ( $change === false ) {
  352. $this->_setError( sprintf( 'Table %s Index %s Column %s is missing in index', $tableName, $indexName, $colName ) );
  353. }
  354. return false;
  355. }
  356. if ( $allIndexes[$indexName][$sequence]['name'] != $colName ) {
  357. if ( $change === false ) {
  358. $this->_setError( sprintf( 'Table %s Index %s Column %s is not the intended column, but %s', $tableName, $indexName, $colName, $allIndexes[$indexName][$sequence]['name'] ) );
  359. }
  360. return false;
  361. }
  362. if ( $column->attributes( 'size' ) && ( $allIndexes[$indexName][$sequence]['size'] != $column->attributes( 'size' ) ) ) {
  363. if ( $change === false ) {
  364. $this->_setError( sprintf( 'Table %s Index %s Column %s Size is %d instead of %s', $tableName, $indexName, $colName, $allIndexes[$indexName][$sequence]['size'], $column->attributes( 'size' ) ) );
  365. }
  366. return false;
  367. }
  368. // don't check ordering, as it can't be checked, and is probably irrelevant.
  369. ++$sequence;
  370. }
  371. }
  372. $this->_setLog( sprintf( 'Table %s Index %s is up-to-date.', $tableName, $indexName ), null, 'ok' );
  373. return true;
  374. }
  375. if ( $change === false ) {
  376. $this->_setError( sprintf( 'Table %s Index %s does not exist', $tableName, $indexName ), null );
  377. }
  378. return false;
  379. }
  380. /**
  381.  * Checks if no surnumerous indexes exist
  382.  * @access private
  383.  *
  384.  * @param  string              $tableName        Name of table (for error strings)
  385.  * @param  array               $allIndexes       From $this->getAllTableIndexes( $table )
  386.  * @param  CBSimpleXMLElement  $indexes          Indexes to check
  387.  * @param  string              $colNamePrefix    Prefix to add to all column names
  388.  * @param  boolean             $drop             TRUE If drops unneeded columns or not
  389.  * @return boolean             TRUE: no other columns exist, FALSE: errors are in $this->getErrors()
  390.  */
  391. function checkOtherIndexesExist( $tableName, &$allIndexes, &$indexes, $colNamePrefix, $drop = false ) {
  392. $isMatching = false;
  393. if ( $indexes->name() == 'indexes' ) {
  394. $isMatching = true;
  395. foreach ( array_keys( $allIndexes ) as $existingIndexName ) {
  396. if ( ! $this->_inXmlChildrenAttribute( $existingIndexName, $indexes, 'index', 'name', $colNamePrefix ) ) {
  397. if ( $drop ) {
  398. if ( ! $this->dropIndex( $tableName, $existingIndexName ) ) {
  399. $isMatching = false;
  400. }
  401. } else {
  402. $isMatching = false;
  403. $this->_setError( sprintf( 'Table %s Index %s exists but should not exist', $tableName, $existingIndexName ), null );
  404. }
  405. }
  406. }
  407. if ( $isMatching && ! $drop ) {
  408. $this->_setLog( sprintf( 'Table %s has no unneeded indexes.', $tableName ), null, 'ok' );
  409. }
  410. }
  411. return $isMatching;
  412. }
  414. /**
  415.  * ROWS CHECKS:
  416.  */
  418. /**
  419.  * Checks if no surnumerous indexes exist
  420.  * @access private
  421.  *
  422.  * @param  string              $tableName        Name of table (for error strings)
  423.  * @param  CBSimpleXMLElement  $rows             <rows...>
  424.  * @param  string              $colNamePrefix    Prefix to add to all column names
  425.  * @param  boolean             $drop             TRUE If drops unneeded columns or not
  426.  * @return boolean             TRUE: no other columns exist, FALSE: errors are in $this->getErrors()
  427.  */
  428. function checkOtherRowsExist( $tableName, &$rows, $colNamePrefix, $drop = false ) {
  429. $isMatching = false;
  430. if ( $rows->name() == 'rows' ) {
  431. $isMatching = true;
  432. $strictRows = ( ( $rows->attributes( 'strict' ) === 'true' ) );
  433. if ( true /* $strictRows */ ) {
  435. // Build $strictRows index of indexes:
  436. $rowIndexes = array();
  437. foreach ( $rows->children() as $row ) {
  438. if ( $row->name() == 'row' ) {
  439. $indexName = $this->_prefixedName( $row, $colNamePrefix, 'index', 'indextype' );
  440. $indexValue = $row->attributes( 'value' );
  441. $indexValueType = $row->attributes( 'valuetype' );
  442. $rowIndexes[$indexName][$indexValue] = $indexValueType;
  443. }
  444. }
  446. // Count and if asked, drop rows which don't match:
  447. $otherRowsCount = $this->countRows( $tableName, $rowIndexes, false );
  448. $isMatching = ( ( $otherRowsCount !== null ) && ( $otherRowsCount == 0 ) );
  449. if ( ! $isMatching ) {
  450. if ( $drop ) {
  451. $isMatching = $this->dropRows( $tableName, $rowIndexes, false );
  452. } else {
  453. $this->_setError( sprintf( 'Table %s has %s rows which should not exist', $tableName, $otherRowsCount ), null );
  454. }
  455. }
  456. }
  458. if ( $isMatching && ! $drop ) {
  459. $this->_setLog( sprintf( 'Table %s has no unneeded rows.', $tableName ), null, 'ok' );
  460. }
  461. }
  462. return $isMatching;
  463. }
  464. /**
  465.  * Drops $row from table $tableName
  466.  * @access private
  467.  *
  468.  * @param  string   $tableName                   Name of table (for error strings)
  469.  * @param  CBSimpleXMLElement  $row              <row index="columnname" indextype="prefixname" value="123" valuetype="sql:int" /> to delete
  470.  * @param  string              $colNamePrefix    Prefix to add to all column names
  471.  * @return boolean
  472.  */
  473. function dropRow( $tableName, &$row, $colNamePrefix ) {
  474. $indexName = $this->_prefixedName( $row, $colNamePrefix, 'index', 'indextype' );
  475. $indexValue = $row->attributes( 'value' );
  476. $indexValueType = $row->attributes( 'valuetype' );
  477. $selection = array( $indexName => array( $indexValue => $indexValueType ) );
  478. return $this->dropRows( $tableName, $selection, true );
  479. }
  481. /**
  482.  * CHANGES OF TABLE STRUCTURE:
  483.  */
  485. /**
  486.  * Changes if a column exists or Creates a new column
  487.  * @access private
  488.  *
  489.  * @param  string              $tableName        Name of table (for error strings)
  490.  * @param  array               $allColumns       From $this->getAllTableColumns( $table )
  491.  * @param  CBSimpleXMLElement  $column           Column to check
  492.  * @param  string              $colNamePrefix    Prefix to add to all column names
  493.  * @param  CBSimpleXMLElement  $columnNameAfter  The column which should be just before this one
  494.  * @return boolean  TRUE: identical (no check on indexes), FALSE: errors are in $this->getErrors()
  495.  */
  496. function changeColumn( $tableName, &$allColumns, &$column, $colNamePrefix, &$columnNameAfter ) {
  497. switch ( $columnNameAfter ) {
  498. case null:
  499. $firstAfterSQL = '';
  500. break;
  502. case 1:
  503. $firstAfterSQL = ' FIRST';
  504. break;
  506. default:
  507. $colNameAfterPrefixed = $this->_prefixedName( $columnNameAfter, $colNamePrefix );
  508. $firstAfterSQL = ' AFTER ' . $this->_db->NameQuote( $colNameAfterPrefixed );
  509. break;
  510. }
  512. $colNamePrefixed = $this->_prefixedName( $column, $colNamePrefix );
  514. $sqlUpdate = '';
  515. $updateResult = true;
  517. if ( isset( $allColumns[$colNamePrefixed] ) ) {
  518. // column exists already, change it:
  519. if ( $column->attributes( 'oldname' ) && array_key_exists( $this->_prefixedName( $column, $colNamePrefix, 'oldname' ), $allColumns ) ) {
  520. $oldColName = $this->_prefixedName( $column, $colNamePrefix, 'oldname' );
  521. } else {
  522. $oldColName = $colNamePrefixed;
  523. }
  524. if ( $column->attributes( 'initialvalue' ) && ( $column->attributes( 'null' ) !== 'true' ) ) {
  525. // we do need to treat the old NULL values specially:
  526. $sqlUpdate = 'UPDATE ' . $this->_db->NameQuote( $tableName )
  527. . "n SET " . $this->_db->NameQuote( $colNamePrefixed )
  528. . ' = ' . $this->_sqlCleanQuote( $column->attributes( 'initialvalue' ), $column->attributes( 'initialvaluetype' ) )
  529. . "n WHERE " . $this->_db->NameQuote( $oldColName ) . ' IS NULL' 
  530. ;
  531. $updateResult = $this->_doQuery( $sqlUpdate );
  532. }
  534. $alteration = 'CHANGE ' . $this->_db->NameQuote( $oldColName );
  535. } else {
  536. // column doesn't exist, create it:
  537. $alteration = 'ADD';
  538. }
  539. $sql = 'ALTER TABLE ' . $this->_db->NameQuote( $tableName )
  540. . "n " . $alteration
  541. . ' ' . $this->_db->NameQuote( $colNamePrefixed )
  542. . ' ' . $this->_fullColumnType( $column )
  543. . $firstAfterSQL
  544. ;
  545. $alterationResult = $this->_doQuery( $sql );
  547. if ( $alterationResult && ( $alteration == 'ADD' ) ) {
  548. if ( $column->attributes( 'initialvalue' ) ) {
  549. $sqlUpdate = 'UPDATE ' . $this->_db->NameQuote( $tableName )
  550. . "n SET " . $this->_db->NameQuote( $colNamePrefixed )
  551. . ' = ' . $this->_sqlCleanQuote( $column->attributes( 'initialvalue' ), $column->attributes( 'initialvaluetype' ) ) 
  552. ;
  553. $updateResult = $this->_doQuery( $sqlUpdate );
  554. }
  555. }
  556. if ( ! $alterationResult ) {
  557. $this->_setError( sprintf( '%s::changeColumn (%s) of Table %s Column %s failed with SQL error: %s', get_class( $this ), $alteration, $tableName, $colNamePrefixed, $this->_db->getErrorMsg() ), $sql );
  558. return false;
  559. } elseif ( ! $updateResult ) {
  560. $this->_setError( sprintf( '%s::changeColumn (UPDATE) of Table %s Column %s failed with SQL error: %s', get_class( $this ), $alteration, $tableName, $colNamePrefixed, $this->_db->getErrorMsg() ), $sqlUpdate );
  561. return false;
  562. } else {
  563. $this->_setLog( sprintf( 'Table %s Column %s %s successfully, type: %s', $tableName, $colNamePrefixed, ( $alteration == 'ADD' ? 'created' : 'changed' ), $this->_fullColumnType( $column ) ),
  564. ( $alteration == 'ADD' ? $sql . ( $sqlUpdate ? ";n" . $sqlUpdate : '' ) : ( $sqlUpdate ?  $sqlUpdate . ";n" : '' ) . $sql ),
  565. 'change' );
  566. return true;
  567. }
  568. }
  569. /**
  570.  * Changes if an index exists or Creates a new index
  571.  * @access private
  572.  *
  573.  * @param  string              $tableName        Name of table (for error strings)
  574.  * @param  array               $allColumns       From $this->getAllTableColumns( $table )
  575.  * @param  CBSimpleXMLElement  $column           Column to check
  576.  * @param  string              $colNamePrefix    Prefix to add to all column names
  577.  * @return boolean  TRUE: identical (no check on indexes), FALSE: errors are in $this->getErrors()
  578.  */
  579. function changeIndex( $tableName, &$allIndexes, &$index, $colNamePrefix ) {
  580. $indexName = $this->_prefixedName( $index, $colNamePrefix );
  582. $queryParts = array();
  583. if ( isset( $allIndexes[$indexName] ) ) {
  584. // index exists already,drop it:
  585. if ( $indexName == 'PRIMARY') {
  586. $queryParts[] = 'DROP PRIMARY KEY';
  587. } else {
  588. $queryParts[] = 'DROP KEY ' . $this->_db->NameQuote( $indexName );
  589. }
  590. $alteration = 'change';
  591. } else {
  592. $alteration = 'new';
  593. }
  594. // Now create new index:
  595. $queryParts[] = 'ADD ' . $this->_fullIndexType( $index, $colNamePrefix );
  597. $sql = 'ALTER TABLE ' . $this->_db->NameQuote( $tableName )
  598. . "n " . implode( ",n ", $queryParts )
  599. ;
  600. $alterationResult = $this->_doQuery( $sql );
  602. if ( ! $alterationResult ) {
  603. $this->_setError( sprintf( '%s::changeIndex (%s) of Table %s Index %s failed with SQL error: %s', get_class( $this ), $alteration, $tableName, $indexName, $this->_db->getErrorMsg() ), $sql );
  604. return false;
  605. } else {
  606. $this->_setLog( sprintf( 'Table %s Index %s successfully %s', $tableName, $indexName, ( $alteration == 'new' ? 'created' : 'changed' ) ), $sql, 'change' );
  607. return true;
  608. }
  609. }
  610. /**
  611.  * Checks if an index exists and has the type of the parameters below:
  612.  * @access private
  613.  *
  614.  * @param  string              $tableName        Name of table (for error strings)
  615.  * @param  CBSimpleXMLElement  $rows             <rows...>
  616.  * @param  CBSimpleXMLElement  $row              <row> to change
  617.  * @param  array               $allColumns       From $this->getAllTableColumns( $table ) : columns which were existing before upgrading columns called before this function
  618.  * @param  string              $colNamePrefix    Prefix to add to all column names
  619.  * @param  boolean             $change           TRUE: changes row, FALSE: checks row
  620.  * @return boolean             TRUE: identical, FALSE: errors are in $this->getErrors()
  621.  */
  622. function checkOrChangeRow( $tableName, &$rows, &$row, &$allColumns, $colNamePrefix, $change = true ) {
  623. $indexName = $this->_prefixedName( $row, $colNamePrefix, 'index', 'indextype' );
  624. $indexValue = $row->attributes( 'value' );
  625. $indexValueType = $row->attributes( 'valuetype' );
  627. $rowsArray = $this->loadRows( $tableName, $indexName, $indexValue, $indexValueType );
  629. $mismatchingFields = array();
  631. if ( is_array( $rowsArray ) && ( count( $rowsArray ) > 0 ) ) {
  632. foreach ( $rowsArray as $rowData ) {
  633. foreach ( $row->children() as $field ) {
  634. if ( $field->name() == 'field' ) {
  635. $strictField = $field->attributes( 'strict' );
  636. $fieldName = $this->_prefixedName( $field, $colNamePrefix );
  637. if ( $strictField || ! isset( $allColumns[$fieldName] ) ) {
  638. // if field is strict, or if column has just been created: compare value to the should be one:
  639. $fieldValue = $field->attributes( 'value' );
  640. $fieldValueType = $field->attributes( 'valuetype' );
  641. if ( ( ! isset( $allColumns[$fieldName] ) )
  642. || ( ! array_key_exists( $fieldName, $rowData ) )
  643. || ( ( $strictField === 'true' ) && ( $this->_adjustToStrictType( $rowData->$fieldName, $fieldValueType ) !== $this->_phpCleanQuote( $fieldValue, $fieldValueType ) ) )
  644. || ( ( $strictField === 'notnull' ) && ( $this->_adjustToStrictType( $rowData->$fieldName, $fieldValueType ) === null ) && ( $this->_phpCleanQuote( $fieldValue, $fieldValueType ) !== null ) )
  645. || ( ( $strictField === 'notzero' ) && ( ( ( $this->_adjustToStrictType( $rowData->$fieldName, $fieldValueType ) === null ) || ( $this->_adjustToStrictType( $rowData->$fieldName, $fieldValueType ) == 0 ) )
  646.  && ( ! ( ( $this->_phpCleanQuote( $fieldValue, $fieldValueType ) === null ) || ( $this->_phpCleanQuote( $fieldValue, $fieldValueType ) === 0 ) ) ) ) )
  647. || ( ( $strictField === 'notempty' ) && ( ( ( $this->_adjustToStrictType( $rowData->$fieldName, $fieldValueType ) === null ) || ( $this->_adjustToStrictType( $rowData->$fieldName, $fieldValueType ) == '' ) )
  648.  && ( ! ( ( $this->_phpCleanQuote( $fieldValue, $fieldValueType ) === null ) || ( $this->_phpCleanQuote( $fieldValue, $fieldValueType ) === '' ) ) ) ) )
  649.    )
  650. {
  651. $mismatchingFields[$fieldName] = $this->_sqlCleanQuote( $fieldValue, $fieldValueType );
  652. }
  653. }
  654. }
  655. }
  656. foreach ( $row->children() as $field ) {
  657. if ( $field->name() == 'field' ) {
  658. $strictField = $field->attributes( 'strict' );
  659. if ( $strictField == 'updatewithfield' ) {
  660. // if field should be updated same time than another field: check if the field is in the list to be upgraded:
  661. $strictSameAsField = $field->attributes( 'strictsameasfield' );
  662. if ( isset( $mismatchingFields[$strictSameAsField] ) ) {
  663. $fieldName = $this->_prefixedName( $field, $colNamePrefix );
  664. $fieldValue = $field->attributes( 'value' );
  665. $fieldValueType = $field->attributes( 'valuetype' );
  666. if ( ( ! array_key_exists( $fieldName, $rowData ) )
  667. || ( $this->_adjustToStrictType( $rowData->$fieldName, $fieldValueType ) !== $this->_phpCleanQuote( $fieldValue, $fieldValueType ) )
  668.    )
  669. {
  670. $mismatchingFields[$fieldName] = $this->_sqlCleanQuote( $fieldValue, $fieldValueType );
  671. }
  672. }
  673. }
  674. }
  675. }
  676. }
  678. if ( count( $mismatchingFields ) > 0 ) {
  679. if ( $change === true ) {
  680. return $this->setFields( $tableName, $row, $mismatchingFields, $colNamePrefix );
  681. } else {
  682. $texts = array();
  683. foreach ($mismatchingFields as $name => $val ) {
  684. $texts[] = sprintf( 'Field %s = %s instead of %s', $name, ( isset( $rowData->$name ) ? $rowData->$name : '""' ), $val );
  685. }
  686. $this->_setError( sprintf( 'Table %s Rows %s = %s : %s', $tableName, $indexName, $indexValue, implode( ', ', $texts ) ) );
  687. return false;
  688. }
  689. } else {
  690. if ( $change === false ) {
  691. $this->_setLog( sprintf( 'Table %s Rows %s = %s are up-to-date.', $tableName, $indexName, $this->_sqlCleanQuote( $indexValue, $indexValueType ) ), null, 'ok' );
  692. }
  693. return true;
  694. }
  695. } else {
  696. if ( $change === true ) {
  697. return $this->insertRow( $tableName, $row, $colNamePrefix );
  698. } else {
  699. $this->_setError( sprintf( 'Table %s Rows %s = %s do not exist', $tableName, $indexName, $this->_sqlCleanQuote( $indexValue, $indexValueType ) ), null );
  700. }
  701. return false;
  702. }
  703. }
  704. /**
  705.  * Load rows from table $tableName
  706.  * @access private
  707.  *
  708.  * @param  string   $tableName        Name of table (for error strings)
  709.  * @param  string   $indexName
  710.  * @param  string   $indexValue
  711.  * @param  string   $indexValueType
  712.  * @return boolean
  713.  */
  714. function loadRows( $tableName, $indexName, $indexValue, $indexValueType ) {
  715. $sql = 'SELECT * FROM ' . $this->_db->NameQuote( $tableName );
  716. if ( $indexName ) {
  717. $sql .= "n WHERE " . $this->_db->NameQuote( $indexName )
  718. . ' = '
  719. . $this->_sqlCleanQuote( $indexValue, $indexValueType )
  720. ;
  721. }
  722. $this->_db->setQuery( $sql );
  723. $result = $this->_db->loadObjectList();
  724. if ( $this->_db->getErrorMsg() ) {
  725. $this->_setError( sprintf( '%s::loadRows of Table %s Rows %s = %s failed with SQL error: %s', get_class( $this ), $tableName, $columnName, $this->_sqlCleanQuote( $indexValue, $indexValueType ), $this->_db->getErrorMsg() ), $sql );
  726. return false;
  727. } else {
  728. // $this->_setLog( sprintf( 'Table %s Rows %s = %s successfully loaded', $tableName, $columnName, $this->_sqlCleanQuote( $indexValue, $indexValueType ) ), $sql, 'change' );
  729. return $result;
  730. }
  731. }
  732. /**
  733.  * Drop rows from table $tableName matching $selection
  734.  * @access private
  735.  *
  736.  * @param  string   $tableName
  737.  * @param  array    $selection        array( 'columnName' => array( 'columnValue' => 'columnValueType' ) )
  738.  * @param  boolean  $positiveSelect   TRUE: select corresponding to selection, FALSE: Select NOT the selection
  739.  * @return boolean                    TRUE: no error, FALSE: error (logged)
  740.  */
  741. function dropRows( $tableName, &$selection, $positiveSelect ) {
  742. $where = $this->_sqlBuiildSelectionWhere( $selection, $positiveSelect );
  743. $sql = 'DELETE FROM ' . $this->_db->NameQuote( $tableName )
  744. . "n WHERE " . $where
  745. ;
  746. if ( ! $this->_doQuery( $sql ) ) {
  747. $this->_setError( sprintf( '%s::dropRows of Table %s Row(s) %s failed with SQL error: %s', get_class( $this ), $tableName, $where, $this->_db->getErrorMsg() ), $sql );
  748. return false;
  749. } else {
  750. $this->_setLog( sprintf( 'Table %s Row(s) %s successfully dropped', $tableName, $where ), $sql, 'change' );
  751. return true;
  752. }
  753. }
  754. /**
  755.  * Counts rows from table $tableName matching $selection
  756.  * @access private
  757.  *
  758.  * @param  string   $tableName
  759.  * @param  array    $selection        array( 'columnName' => array( 'columnValue' => 'columnValueType' ) )
  760.  * @param  boolean  $positiveSelect   TRUE: select corresponding to selection, FALSE: Select NOT the selection
  761.  * @return boolean                    TRUE: no error, FALSE: error (logged)
  762.  */
  763. function countRows( $tableName, &$selection, $positiveSelect ) {
  764. $where = $this->_sqlBuiildSelectionWhere( $selection, $positiveSelect );
  765. $sql = 'SELECT COUNT(*) FROM ' . $this->_db->NameQuote( $tableName )
  766. . "n WHERE " . $where
  767. ;
  768. $this->_db->setQuery( $sql );
  769. $result = $this->_db->loadResult();
  770. if ( $result === null ) {
  771. $this->_setError( sprintf( '%s::countRows of Table %s Row(s) %s failed with SQL error: %s', get_class( $this ), $tableName, $where, $this->_db->getErrorMsg() ), $sql );
  772. }
  773. return $result;
  774. }
  775. /**
  776.  * Counts rows from table $tableName matching $selection
  777.  * @access private
  778.  *
  779.  * @param  string              $tableName
  780.  * @param  CBSimpleXMLElement  $row                <row index="columnname" indextype="prefixname" value="123" valuetype="sql:int" /> to delete
  781.  * @param  array               $mismatchingFields  array( 'columnName' => 'SQL-safe value' )
  782.  * @param  string              $colNamePrefix    Prefix to add to all column names
  783.  * @return boolean                                 TRUE: no error, FALSE: error (logged)
  784.  */
  785. function setFields( $tableName, &$row, &$mismatchingFields, $colNamePrefix ) {
  786. $indexName = $this->_prefixedName( $row, $colNamePrefix, 'index', 'indextype' );
  787. $indexValue = $row->attributes( 'value' );
  788. $indexValueType = $row->attributes( 'valuetype' );
  790. $selection = array( $indexName => array( $indexValue => $indexValueType ) );
  791. $where = $this->_sqlBuiildSelectionWhere( $selection, true );
  793. $setFields = array();
  794. foreach ( $mismatchingFields as $name => $quotedValue ) {
  795. $setFields[] = $this->_db->NameQuote( $name ) . ' = ' . $quotedValue;
  796. }
  797. $setFieldsText = implode( ', ', $setFields );
  798. $sql = 'UPDATE ' . $this->_db->NameQuote( $tableName )
  799. . "n SET " . $setFieldsText
  800. . "n WHERE " . $where
  801. ;
  802. if ( ! $this->_doQuery( $sql ) ) {
  803. $this->_setError( sprintf( '%s::setFields of Table %s Row %s Fields %s failed with SQL error: %s', get_class( $this ), $tableName, $where, $setFieldsText, $this->_db->getErrorMsg() ), $sql );
  804. return false;
  805. } else {
  806. $this->_setLog( sprintf( 'Table %s Row %s successfully updated', $tableName, $where ), $sql, 'change' );
  807. return true;
  808. }
  809. }
  810. /**
  811.  * Checks if an index exists and has the type of the parameters below:
  812.  * @access private
  813.  *
  814.  * @param  string              $tableName        Name of table (for error strings)
  815.  * @param  CBSimpleXMLElement  $row              <row> to change
  816.  * @param  string              $colNamePrefix    Prefix to add to all column names
  817.  * @return boolean             TRUE: success, FALSE: errors are in $this->getErrors()
  818.  */
  819. function insertRow( $tableName, &$row, $colNamePrefix ) {
  820. $indexName = $this->_prefixedName( $row, $colNamePrefix, 'index', 'indextype' );
  821. $indexValue = $row->attributes( 'value' );
  822. $indexValueType = $row->attributes( 'valuetype' );
  824. if ( $row->name() == 'row' ) {
  825. $sqlFieldNames = array();
  826. $sqlFieldValues = array();
  827. foreach ( $row->children() as $field ) {
  828. if ( $field->name() == 'field' ) {
  829. $fieldName = $this->_prefixedName( $field, $colNamePrefix );
  830. $fieldValue = $field->attributes( 'value' );
  831. $fieldValueType = $field->attributes( 'valuetype' );
  832. if ( ( $fieldName == $indexName ) && ( ( $fieldValue != $indexValue ) || ( $fieldValueType != $indexValueType ) ) ) {
  833. $this->_setError( sprintf( '%s::insertRow Error in XML: Table %s Row %s = %s (type %s) trying to insert different Field Value or type: %s = %s (type %s)', get_class( $this ), $tableName, $indexName, $indexValue, $indexValueType, $fieldName, $fieldValue, $fieldValueType ), null );
  834. return false;
  835. }
  836. if ( isset( $sqlFieldNames[$fieldName] ) ) {
  837. $this->_setError( sprintf( '%s::insertRow Error in XML: Table %s Row %s = %s : Field %s is defined twice in XML', get_class( $this ), $tableName, $indexName, $indexValue, $fieldName ), null );
  838. return false;
  839. }
  840. $sqlFieldNames[$fieldName] = $this->_db->NameQuote( $fieldName );
  841. $sqlFieldValues[$fieldName] = $this->_sqlCleanQuote( $fieldValue, $fieldValueType );
  842. }
  843. }
  844. if ( ! isset( $sqlFieldNames[$indexName] ) ) {
  845. $sqlFieldNames[$indexName] = $this->_db->NameQuote( $indexName );
  846. $sqlFieldValues[$indexName] = $this->_sqlCleanQuote( $indexValue, $indexValueType );
  847. }
  849. if ( count( $sqlFieldNames ) > 0 ) {
  850. $sqlColumnsText = '(' . implode( ',', $sqlFieldNames ) . ')';
  851. $sqlColumnsValues = array();
  852. $sqlColumnsValues[] = '(' . implode( ',', $sqlFieldValues ) . ')';
  853. } elseif ( $indexName ) {
  854. $sqlColumnsText = '(' . $this->_db->NameQuote( $indexName ) . ')';
  855. $sqlColumnsValues = '(' . $this->_sqlCleanQuote( $indexValue, $indexValueType );
  856. } else {
  857. $sqlColumnsText = null;
  858. }
  859. if ( $sqlColumnsText != null ) {
  860. $sql = 'INSERT INTO ' . $this->_db->NameQuote( $tableName )
  861. . "n " . $sqlColumnsText
  862. . "n VALUES " . implode( ",n        ", $sqlColumnsValues )
  863. ;
  864. if ( ! $this->_doQuery( $sql ) ) {
  865. $this->_setError( sprintf( '%s::insertRow of Table %s Row %s = %s Fields %s = %s failed with SQL error: %s', get_class( $this ), $tableName, $indexName, $indexValue, $sqlColumnsText, $sqlColumnsValues, $this->_db->getErrorMsg() ), $sql );
  866. return false;
  867. } else {
  868. $this->_setLog( sprintf( 'Table %s Row %s = %s successfully updated', $tableName, $indexName, $indexValue ), $sql, 'change' );
  869. return true;
  870. }
  872. }
  873. }
  874. $this->_setError( sprintf( '%s::insertRow : Error in SQL: No values to insert Row %s = %s (type %s)', $tableName, $indexName, $indexValue, $indexValueType ), $sql );
  875. return true;
  877. }
  878. /**
  879.  * Builds SQL WHERE statement (without WHERE) based on array $selection
  880.  * @access private
  881.  *
  882.  * @param  array    $selection        array( 'columnName' => array( 'columnValue' => 'columnValueType' ) )
  883.  * @param  boolean  $positiveSelect   TRUE: select corresponding to selection, FALSE: Select NOT the selection
  884.  * @return boolean  True: no error, False: error (logged)
  885.  */
  886. function _sqlBuiildSelectionWhere( &$selection, $positiveSelect ) {
  887. $where = array();
  888. foreach ( $selection as $colName => $valuesArray ) {
  889. $values = array();
  890. foreach ( $valuesArray as $colValue => $colValueType ) {
  891. $values[] = $this->_sqlCleanQuote( $colValue, $colValueType );
  892. }
  893. if ( count( $values ) > 0 ) {
  894. if ( count( $values ) > 1 ) {
  895. $where[] = $this->_db->NameQuote( $colName ) . ' IN (' .implode( ',', $values ) . ')';
  896. } else {
  897. $where[] = $this->_db->NameQuote( $colName ) . ' = ' . $values[0];
  898. }
  899. }
  900. }
  901. $positiveWhere = '(' . implode( ') OR (', $where ) . ')';
  902. if ( $positiveSelect ) {
  903. return $positiveWhere;
  904. } else {
  905. return 'NOT(' . $positiveWhere . ')';
  906. }
  907. }
  908. /**
  909.  * Drops column $ColumnName from table $tableName
  910.  * @access private
  911.  *
  912.  * @param  string   $tableName        Name of table (for error strings)
  913.  * @param  string   $columnName       Old name of column to change
  914.  * @return boolean                    TRUE: no error, FALSE: errors are in $this->getErrors()
  915.  */
  916. function dropColumn( $tableName, $columnName ) {
  917. $sql = 'ALTER TABLE ' . $this->_db->NameQuote( $tableName )
  918. . "n DROP COLUMN " . $this->_db->NameQuote( $columnName )
  919. ;
  920. if ( ! $this->_doQuery( $sql ) ) {
  921. $this->_setError( sprintf( '%s::dropColumn of Table %s Column %s failed with SQL error: %s', get_class( $this ), $tableName, $columnName, $this->_db->getErrorMsg() ), $sql );
  922. return false;
  923. } else {
  924. $this->_setLog( sprintf( 'Table %s Column %s successfully dropped', $tableName, $columnName ), $sql, 'change' );
  925. return true;
  926. }
  927. }
  928. /**
  929.  * Drops INDEX $indexName from table $tableName
  930.  * @access private
  931.  *
  932.  * @param  string   $tableName        Name of table (for error strings)
  933.  * @param  string   $indexName       Old name of column to change
  934.  * @return boolean                    TRUE: no error, FALSE: errors are in $this->getErrors()
  935.  */
  936. function dropIndex( $tableName, $indexName ) {
  937. $sql = 'ALTER TABLE ' . $this->_db->NameQuote( $tableName );
  938. if ( $indexName == 'PRIMARY' ) {
  939. $sql .= "n DROP PRIMARY KEY";
  940. } else {
  941. $sql .= "n DROP KEY " . $this->_db->NameQuote( $indexName );
  942. }
  943. if ( ! $this->_doQuery( $sql ) ) {
  944. $this->_setError( sprintf( '%s::dropIndex of Table %s Index %s failed with SQL error: %s', get_class( $this ), $tableName, $indexName, $this->_db->getErrorMsg() ), $sql );
  945. return false;
  946. } else {
  947. $this->_setLog( sprintf( 'Table %s Index %s successfully dropped', $tableName, $indexName ), $sql, 'change' );
  948. return true;
  949. }
  950. }
  951. /**
  952.  * Drops table $tableName
  953.  * @access private
  954.  *
  955.  * @param  string   $tableName        Name of table (for error strings)
  956.  * @return boolean                    TRUE: no error, FALSE: errors are in $this->getErrors()
  957.  */
  958. function dropTable( $tableName ) {
  959. $sql = 'DROP TABLE ' . $this->_db->NameQuote( $tableName )
  960. ;
  961. if ( ! $this->_doQuery( $sql ) ) {
  962. $this->_setError( sprintf( '%s::dropTable of Table %s failed with SQL error: %s', get_class( $this ), $tableName, $this->_db->getErrorMsg() ), $sql );
  963. return false;
  964. } else {
  965. $this->_setLog( sprintf( 'Table %s successfully dropped', $tableName ), $sql, 'change' );
  966. return true;
  967. }
  968. }
  969. /**
  970.  * Creates a new table
  971.  * @access private
  972.  *
  973.  * @param  CBSimpleXMLElement  $table  Table
  974.  * @param  string              $colNamePrefix    Prefix to add to all column names
  975.  * @return boolean                               True: success, False: failure
  976.  */
  977. function createTable( &$table, $colNamePrefix ) {
  978. if ( $table->name() == 'table' ) {
  979. $tableName = $this->_prefixedName( $table, $colNamePrefix );
  980. $columns =& $table->getElementByPath( 'columns' );
  981. if ( $tableName && ( $columns !== false ) ) {
  982. $sqlColumns = array();
  983. $auto_increment_initial_value = '';
  985. foreach ( $columns->children() as $column ) {
  986. if ( $column->name() == 'column' ) {
  987. $colNamePrefixed = $this->_prefixedName( $column, $colNamePrefix );
  988. $sqlColumns[] = "n " . $this->_db->NameQuote( $colNamePrefixed )
  989. . ' ' . $this->_fullColumnType( $column )
  990. ;
  991. if ( (int) $column->attributes( 'auto_increment' ) ) {
  992. $auto_increment_initial_value = ' AUTO_INCREMENT=' . (int) $column->attributes( 'auto_increment' );
  993. }
  994. }
  995. }
  997. $indexes =& $table->getElementByPath( 'indexes' );
  998. if ( $indexes !== false ) {
  999. foreach ( $indexes->children() as $index ) {
  1000. if ( $index->name() == 'index' ) {
  1001. $sqlIndexText = $this->_fullIndexType( $index, $colNamePrefix );
  1002. if ( $sqlIndexText ) {
  1003. $sqlColumns[] = "n " . $sqlIndexText;
  1004. }
  1005. }
  1006. }
  1007. }
  1008. $sql = 'CREATE TABLE ' . $this->_db->NameQuote( $tableName )
  1009. . ' ('
  1010. . implode( ',', $sqlColumns )
  1011. . "n) ENGINE=MyISAM"
  1012. . $auto_increment_initial_value
  1013. ;
  1014. if ( ! $this->_doQuery( $sql ) ) {
  1015. $this->_setError( sprintf( '%s::createTableof Table %s failed with SQL error: %s', get_class( $this ), $tableName, $this->_db->getErrorMsg() ), $sql );
  1016. return false;
  1017. } else {
  1018. $this->_setLog( sprintf( 'Table %s successfully created', $tableName ), $sql, 'change' );
  1019. return true;
  1020. }
  1021. }
  1022. }
  1023. return false;
  1024. }
  1026. /**
  1027.  * UTILITY FUNCTIONS:
  1028.  */
  1030. /**
  1031.  * Sets modifying query and performs it, IF NOT in dry run mode.
  1032.  * If in dry run mode, returns true
  1033.  * @access private
  1034.  *
  1035.  * @param  string  $sql
  1036.  * @return boolean
  1037.  */
  1038. function _doQuery( $sql ) {
  1039. if ( $this->_dryRun ) {
  1040. return true;
  1041. } else {
  1042. $this->_db->SetQuery( $sql );
  1043. return $this->_db->query();
  1044. }
  1045. }
  1046. /**
  1047.  * Utility: Checks if $needle is the $attribute of a child of $xml
  1048.  * @access private
  1049.  *
  1050.  * @param  string              $needle
  1051.  * @param  CBSimpleXMLElement  $xml
  1052.  * @param  string              $attribute
  1053.  * @param  string              $colNamePrefix    Prefix to add to all column names
  1054.  * @return boolean
  1055.  */
  1056. function _inXmlChildrenAttribute( $needle, &$xml, $name, $attribute, $colNamePrefix) {
  1057. foreach ( $xml->children() as $chld ) {
  1058. if ( $chld->name() == $name ) {
  1059. $colNamePrefixed = $this->_prefixedName( $chld, $colNamePrefix, $attribute );
  1060. if ( $needle == $colNamePrefixed ) {
  1061. return true;
  1062. }
  1063. }
  1064. }
  1065. return false;
  1066. }
  1067. /**
  1068.  * Converts a XML description of a SQL column into a full SQL type
  1069.  *
  1070.  * <column name="_rate" nametype="namesuffix" type="sql:decimal(16,8)" unsigned="true" null="true" default="NULL" auto_increment="100" />
  1071.  *
  1072.  * Returns: $fulltype: 'decimal(16,8) unsigned NULL DEFAULT NULL'
  1073.  * @access private
  1074.  *
  1075.  * @param  CBSimpleXMLElement  $column
  1076.  * @return string|boolean              Full SQL creation type or FALSE in case of error
  1077.  */
  1078. function _fullColumnType( &$column ) {
  1079. $fullType = false;
  1081. if ( $column->name() == 'column' ) {
  1082. // $colName = $column->attributes( 'name' );
  1083. // $colNameType = $column->attributes( 'nametype' );
  1084. // if ( $colNameType == 'namesuffix' ) {
  1085. // $colName = $colNamePrefix . $colName;
  1086. // }
  1087. $type = $column->attributes( 'type' );
  1088. $unsigned = $column->attributes( 'unsigned' );
  1089. $null = $column->attributes( 'null' );
  1090. $default = $column->attributes( 'default' );
  1091. $auto_increment = $column->attributes( 'auto_increment' );
  1094. if ( cbStartOfStringMatch( $type, 'sql:' ) ) {
  1095. $type = trim( substr( $type, 4 ) ); // remove 'sql:'
  1096. if ( $type ) {
  1097. $notQuoted = array( 'int', 'float', 'tinyint', 'bigint', 'decimal', 'boolean', 'bit', 'serial', 'smallint', 'mediumint', 'double', 'year' );
  1098. $isInt = false;
  1099. foreach ( $notQuoted as $n ) {
  1100. if ( cbStartOfStringMatch( $type, $n ) ) {
  1101. $isInt = true;
  1102. break;
  1103. }
  1104. }
  1105. $fullType = $type;
  1106. if ( $unsigned == 'true' ) {
  1107. $fullType .= ' unsigned';
  1108. }
  1109. if ( $null !== 'true' ) {
  1110. $fullType .= ' NOT NULL';
  1111. }
  1112. if ( ! in_array( $type, array( 'text', 'blob', 'tinytext', 'mediumtext', 'longtext', 'tinyblob', 'mediumblob', 'longblob' ))) {
  1113. // BLOB and TEXT columns cannot have DEFAULT values. http://dev.mysql.com/doc/refman/5.0/en/blob.html
  1114. if ( $default !== null ) {
  1115. $fullType .= ' DEFAULT ' . ( ( $isInt || ( $default === 'NULL' ) ) ? $default : $this->_db->Quote( $default ) );
  1116. } elseif ( ! $auto_increment ) {
  1117. // MySQL 5.0.51a and b have a bug: they need a default value always to be able to return it correctly in SHOW COLUMNS FROM ...:
  1118. if ( $null === 'true' ) {
  1119. $default = 'NULL';
  1120. } elseif ( $isInt ) {
  1121. $default = 0;
  1122. } elseif ( in_array( $type, array( 'datetime', 'date', 'time' ) ) ) {
  1123. $default = $this->_db->getNullDate( $type );
  1124. } else {
  1125. $default = '';
  1126. }
  1127. $fullType .= ' DEFAULT ' . ( ( $isInt || ( $default === 'NULL' ) ) ? $default : $this->_db->Quote( $default ) );
  1128. }
  1129. }
  1130. if ( $auto_increment ) {
  1131. $fullType .= ' auto_increment';
  1132. }
  1133. }
  1134. }
  1135. }
  1136. return $fullType;
  1137. }
  1138. /**
  1139.  * Converts a mysql type with 'sql:' prefix to a xmlsql sql:/const: type (without prefix).
  1140.  *
  1141.  * @param  string  $type   MySql type, E.g.: 'sql:varchar(255)' (with 'sql:' prefix)
  1142.  * @return string          Xmlsql type, E.g.: 'string' (without 'sql:' or 'const:' prefix)
  1143.  */
  1144. function mysqlToXmlsql( $type ) {
  1145. $mysqlTypes = array( 'varchar' => 'string',
  1146. 'character' => 'string',
  1147. 'char' => 'string',
  1148. 'binary' => 'string',
  1149. 'varbinary' => 'string',
  1150. 'tinyblob' => 'string',
  1151. 'blob' => 'string',
  1152. 'mediumblob' => 'string',
  1153. 'longblob' => 'string',
  1154. 'tinytext' => 'string',
  1155. 'mediumtext' => 'string',
  1156. 'longtext' => 'string',
  1157. 'text' => 'string',
  1158. 'tinyint' => 'int',
  1159. 'smallint' => 'int',
  1160. 'mediumint' => 'int',
  1161. 'bigint' => 'int',
  1162. 'integer' => 'int',
  1163. 'int' => 'int',
  1164. 'bit' => 'int',
  1165. 'boolean' => 'int',
  1166. 'year' => 'int',
  1167. 'float' => 'float',
  1168. 'double' => 'float',
  1169. 'decimal' => 'float',
  1170. 'date' => 'date',
  1171. 'datetime' => 'datetime',
  1172. 'timestamp' => 'datetime',
  1173. 'time' => 'time',
  1174. 'enum' => 'string'
  1175. // missing since not in SQL standard: SET, and ENUM above is a little simplified since only partly supported.
  1176.  );
  1177. $cleanedType = preg_replace( '/^sql:([^\(]*)\(?.*/', '$1', $type );
  1178. if ( isset( $mysqlTypes[$cleanedType] ) ) {
  1179. return $mysqlTypes[$cleanedType];
  1180. } else {
  1181. trigger_error( sprintf( 'mysqlToXmlsql: Unknown SQL type %s (i am extracting "%s" from type)', $type, $cleanedType ), E_USER_WARNING );
  1182. return $type;
  1183. }
  1184. }
  1185. /**
  1186.  * Returns the possible default default values for that type
  1187.  *
  1188.  * @param  string $type
  1189.  * @return array  of string
  1190.  */
  1191. function defaultValuesOfTypes( $type ) {
  1192. $defaultNulls = array( 'string' => array( ''  ),
  1193. 'int' => array( '', '0' ),
  1194. 'float' => array( '', '0' ),
  1195. 'date' => array( '', '0000-00-00' ),
  1196. 'datetime' => array( '', '0000-00-00 00:00:00' ),
  1197. 'time' => array( '', '00:00:00' ),
  1198. 'enum' => array( '' )
  1199.  );
  1200. if ( isset( $defaultNulls[$type] ) ) {
  1201. return $defaultNulls[$type];
  1202. } else {
  1203. trigger_error( sprintf( 'defaultValuesOfTypes: Unknown SQL type %s', $type ), E_USER_WARNING );
  1204. return array( '', 0 );
  1205. }
  1206. }
  1207. /**
  1208.  * Cleans and makes a value SQL safe depending on the type that is enforced.
  1209.  * @access private
  1210.  *
  1211.  * @param  mixed   $fieldValue
  1212.  * @param  string  $type
  1213.  * @return string
  1214.  */
  1215. function _sqlCleanQuote( $fieldValue, $type ) {
  1216. $typeArray = explode( ':', $type, 3 );
  1217. if ( count( $typeArray ) < 2 ) {
  1218. $typeArray = array( 'const' , $type );
  1219. }
  1221. switch ( $typeArray[1] ) {
  1222. case 'int':
  1223. $value = (int) $fieldValue;
  1224. break;
  1225. case 'float':
  1226. $value = (float) $fieldValue;
  1227. break;
  1228. case 'formula':
  1229. $value = $fieldValue;
  1230. break;
  1231. case 'field': // this is temporarly handled here
  1232. $value = $this->_db->NameQuote( $fieldValue );
  1233. break;
  1234. case 'datetime':
  1235. if ( preg_match( '/^[0-9]{4}-[01][0-9]-[0-3][0-9] [0-2][0-9](:[0-5][0-9]){2}$/', $fieldValue ) ) {
  1236. $value = $this->_db->Quote( $fieldValue );
  1237. } else {
  1238. $value = "''";
  1239. }
  1240. break;
  1241. case 'date':
  1242. if ( preg_match( '/^[0-9]{4}-[01][0-9]-[0-3][0-9]$/', $fieldValue ) ) {
  1243. $value = $this->_db->Quote( $fieldValue );
  1244. } else {
  1245. $value = "''";
  1246. }
  1247. break;
  1248. case 'string':
  1249. $value = $this->_db->Quote( $fieldValue );
  1250. break;
  1251. case 'null':
  1252. if ( $fieldValue != 'NULL' ) {
  1253. trigger_error( sprintf( 'CBSQLUpgrader::_sqlCleanQuote: ERROR: field type sql:null has not NULL value' ) );
  1254. }
  1255. $value = 'NULL';
  1256. break;
  1258. default:
  1259. trigger_error( 'CBSQLUpgrader::_sqlQuoteValueType: ERROR_UNKNOWN_TYPE: ' . htmlspecialchars( $type ), E_USER_NOTICE );
  1260. $value = $this->_db->Quote( $fieldValue ); // false;
  1261. break;
  1262. }
  1263. return (string) $value;
  1264. }
  1265. /**
  1266.  * Cleans and makes a value comparable to the SQL stored value in a comprofilerDBTable object, depending on the type that is enforced.
  1267.  * @access private
  1268.  *
  1269.  * @param  mixed   $fieldValue
  1270.  * @param  string  $type
  1271.  * @return string
  1272.  */
  1273. function _phpCleanQuote( $fieldValue, $type ) {
  1274. $typeArray = explode( ':', $type, 3 );
  1275. if ( count( $typeArray ) < 2 ) {
  1276. $typeArray = array( 'const' , $type );
  1277. }
  1279. switch ( $typeArray[1] ) {
  1280. case 'int':
  1281. $value = (int) $fieldValue;
  1282. break;
  1283. case 'float':
  1284. $value = (float) $fieldValue;
  1285. break;
  1286. case 'formula':
  1287. $value = $fieldValue; // this is temporarly done so
  1288. break;
  1289. case 'field': // this is temporarly handled here
  1290. $value = $fieldValue;
  1291. break;
  1292. case 'datetime':
  1293. if ( preg_match( '/^[0-9]{4}-[01][0-9]-[0-3][0-9] [0-2][0-9](:[0-5][0-9]){2}$/', $fieldValue ) ) {
  1294. $value = (string) $fieldValue;
  1295. } else {
  1296. $value = '';
  1297. }
  1298. break;
  1299. case 'date':
  1300. if ( preg_match( '/^[0-9]{4}-[01][0-9]-[0-3][0-9]$/', $fieldValue ) ) {
  1301. $value = (string) $fieldValue;
  1302. } else {
  1303. $value = '';
  1304. }
  1305. break;
  1306. case 'string':
  1307. $value = (string) $fieldValue;
  1308. break;
  1309. case 'null':
  1310. if ( $fieldValue != 'NULL' ) {
  1311. trigger_error( sprintf( 'CBSQLUpgrader::_phpCleanQuote: ERROR: field type sql:null has not NULL value' ) );
  1312. }
  1313. $value = null;
  1314. break;
  1316. default:
  1317. trigger_error( 'CBSQLUpgrader::_sqlQuoteValueType: ERROR_UNKNOWN_TYPE: ' . htmlspecialchars( $type ), E_USER_NOTICE );
  1318. $value = (string) $fieldValue; // false;
  1319. break;
  1320. }
  1321. return $value;
  1322. }
  1323. /**
  1324.  * Cleans and makes a value comparable to the SQL stored value in a comprofilerDBTable object, depending on the type that is enforced.
  1325.  * @access private
  1326.  *
  1327.  * @param  string|null  $fieldValue
  1328.  * @param  string  $type
  1329.  * @return mixed
  1330.  */
  1331. function _adjustToStrictType( $fieldValue, $type ) {
  1332. $typeArray = explode( ':', $type, 3 );
  1333. if ( count( $typeArray ) < 2 ) {
  1334. $typeArray = array( 'const' , $type );
  1335. }
  1337. $value = $fieldValue;
  1338. if ( $fieldValue !== null ) {
  1339. switch ( $typeArray[1] ) {
  1340. case 'int':
  1341. if ( is_int( $fieldValue ) || preg_match( '/^d++$/', $fieldValue ) ) {
  1342. $value = (int) $fieldValue;
  1343. }
  1344. break;
  1345. case 'float':
  1346. if ( is_float( $fieldValue ) || ( preg_match( '/^(((+|-)?d+(.d*)?([Ee](+|-)?d+)?)|((+|-)?(d*.)?d+([Ee](+|-)?d+)?))$/', $fieldValue ) ) ) {
  1347. $value = (float) $fieldValue;
  1348. }
  1349. break;
  1350. case 'formula':
  1351. $value = $fieldValue; // this is temporarly done so
  1352. break;
  1353. case 'field': // this is temporarly handled here
  1354. $value = $fieldValue;
  1355. break;
  1356. case 'datetime':
  1357. if ( preg_match( '/^[0-9]{4}-[01][0-9]-[0-3][0-9] [0-2][0-9](:[0-5][0-9]){2}$/', $fieldValue ) ) {
  1358. $value = (string) $fieldValue;
  1359. } else {
  1360. $value = '';
  1361. }
  1362. break;
  1363. case 'date':
  1364. if ( preg_match( '/^[0-9]{4}-[01][0-9]-[0-3][0-9]$/', $fieldValue ) ) {
  1365. $value = (string) $fieldValue;
  1366. } else {
  1367. $value = '';
  1368. }
  1369. break;
  1370. case 'string':
  1371. if ( is_string( $fieldValue ) ) {
  1372. $value = (string) $fieldValue;
  1373. }
  1374. break;
  1375. case 'null':
  1376. if ( $fieldValue === null ) {
  1377. $value = null;
  1378. }
  1379. break;
  1381. default:
  1382. trigger_error( 'CBSQLUpgrader::_sqlQuoteValueType: ERROR_UNKNOWN_TYPE: ' . htmlspecialchars( $type ), E_USER_NOTICE );
  1383. $value = (string) $fieldValue; // false;
  1384. break;
  1385. }
  1386. }
  1387. return $value;
  1388. }
  1389. /**
  1390.  * Converts a XML description of a SQL index into a full SQL type
  1391.  *
  1392.  * <index name="PRIMARY" type="primary">
  1393.  * <column name="id" />
  1394.  * </index>
  1395.  * <index name="rate_chars">
  1396.  * <column name="rate" />
  1397.  * <column name="_mychars" nametype="namesuffix" size="8" ordering="DESC" />
  1398.  * </index>
  1399.  * <index name="myrate" type="unique" using="btree">
  1400.  * <column name="rate" />
  1401.  * </index>
  1402.  *
  1403.  * Returns: $fulltype: 'decimal(16,8) unsigned NULL DEFAULT NULL'
  1404.  * @access private
  1405.  *
  1406.  * @param  CBSimpleXMLElement  $index
  1407.  * @param  string              $colNamePrefix    Prefix to add to all column names
  1408.  * @return string|boolean                        Full SQL creation type or NULL in case of no index/error
  1409.  */
  1410. function _fullIndexType( &$index, $colNamePrefix ) {
  1411. $sqlIndexText = null;
  1413. if ( $index->name() == 'index' ) {
  1414. // first collect all columns of this index:
  1415. $indexColumns = array();
  1416. foreach ( $index->children() as $column ) {
  1417. if ( $column->name() == 'column' ) {
  1418. $colNamePrefixed = $this->_prefixedName( $column, $colNamePrefix );
  1419. $indexColText = $this->_db->NameQuote( $colNamePrefixed );
  1420. if ( $column->attributes( 'size' ) ) {
  1421. $indexColText .= ' (' . (int) $column->attributes( 'size' ) . ')';
  1422. }
  1423. if ( $column->attributes( 'ordering' ) ) {
  1424. $indexColText .= ' ' . $this->_db->getEscaped( $column->attributes( 'ordering' ) );
  1425. }
  1427. $indexColumns[] = $indexColText;
  1428. }
  1429. }
  1430. if ( count( $indexColumns ) > 0 ) {
  1431. // then build the index creation SQL:
  1432. if ( $index->attributes( 'type' ) ) {
  1433. // PRIMARY, UNIQUE, FULLTEXT, SPATIAL:
  1434. $sqlIndexText .= $this->_db->getEscaped( strtoupper( $index->attributes( 'type' ) ) ) . ' ';
  1435. }
  1436. $sqlIndexText .= 'KEY ';
  1437. if ( $index->attributes( 'type' ) !== 'primary' ) {
  1438. $sqlIndexText .= $this->_db->NameQuote( $this->_prefixedName( $index, $colNamePrefix ) ) . ' ';
  1439. }
  1440. if ( $index->attributes( 'using' ) ) {
  1441. // BTREE, HASH, RTREE:
  1442. $sqlIndexText .= 'USING ' . $this->_db->getEscaped( $index->attributes( 'using' ) ) . ' ';
  1443. }
  1444. $sqlIndexText .= '(' . implode( ', ', $indexColumns ) . ')';
  1445. }
  1446. }
  1447. return $sqlIndexText;
  1448. }
  1449. /**
  1450.  * Prefixes the $attribute of $column (or table or other xml element) with
  1451.  * $colNamePrefix if $column->attributes( 'nametype' ) == 'namesuffix' or 'nameprefix'
  1452.  * @access private
  1453.  *
  1454.  * @param  CBSimpleXMLElement  $column
  1455.  * @param  string              $colNamePrefix
  1456.  * @param  string              $attribute      
  1457.  * @param  string              $modifyingAttr
  1458.  * @return string
  1459.  */
  1460. function _prefixedName( &$column, $colNamePrefix, $attribute = 'name', $modifyingAttr = 'nametype' ) {
  1461. $colName = $column->attributes( $attribute );
  1462. $colNameType = $column->attributes( $modifyingAttr );
  1464. switch ( $colNameType ) {
  1465. case 'nameprefix':
  1466. $colName .= $colNamePrefix;
  1468. break;
  1469. case 'namesuffix':
  1470. $colName = $colNamePrefix . $colName;
  1471. break;
  1473. default:
  1474. break;
  1475. }
  1476. return $colName;
  1477. }
  1478. /**
  1479.  * Checks if all columns of a xml description of all tables of a database matches the database
  1480.  *
  1481.  * Warning: if ( $change && $strictlyColumns ) it will DROP not described columns !!!
  1482.  * @access private
  1483.  *
  1484.  * @param  CBSimpleXMLElement  $table
  1485.  * @param  string              $colNamePrefix    Prefix to add to all column names
  1486.  * @param  boolean             $change           FALSE: only check, TRUE: change database to match description (deleting columns if $strictlyColumns == true)
  1487.  * @param  boolean|null        $strictlyColumns  FALSE: allow for other columns, TRUE: doesn't allow for other columns, NULL: checks for attribute 'strict' in table
  1488.  * @return boolean             TRUE: matches, FALSE: don't match
  1489.  */
  1490. function checkXmlTableDescription( &$table, $colNamePrefix = '', $change = false, $strictlyColumns = false ) {
  1491. $isMatching = false;
  1492. if ( $table->name() == 'table' ) {
  1493. $tableName = $this->_prefixedName( $table, $colNamePrefix );
  1494. $columns =& $table->getElementByPath( 'columns' );
  1495. if ( $tableName && ( $columns !== false ) ) {
  1496. if ( $strictlyColumns === null ) {
  1497. $strictlyColumns = ( $table->attributes( 'strict' ) == 'true' );
  1498. }
  1499. $isMatching = true;
  1500. $allColumns = $this->getAllTableColumns( $tableName );
  1501. if ( $allColumns === false ) {
  1502. // table doesn't exist:
  1503. if ( $change ) {
  1504. if ( $this->createTable( $table, $colNamePrefix ) ) {
  1505. $allColumns = $this->getAllTableColumns( $tableName );
  1506. } else {
  1507. $isMatching = false;
  1508. }
  1509. } else {
  1510. $this->_setError( sprintf( 'Table %s does not exist', $tableName ), null );
  1511. $isMatching = false;
  1512. }
  1513. } else {
  1514. // Table exists:
  1515. // 1) Check columns:
  1516. if ( $strictlyColumns ) {
  1517. $columnBefore = 1;
  1518. } else {
  1519. $columnBefore = null;
  1520. }
  1521. foreach ( $columns->children() as $column ) {
  1522. if ( $column->name() == 'column' ) {
  1523. if ( ! $this->checkColumnExistsType( $tableName, $allColumns, $column, $colNamePrefix, $change ) ) {
  1524. if ( ( ! $change ) || ( ! $this->changeColumn( $tableName, $allColumns, $column, $colNamePrefix, $columnBefore ) ) ) {
  1525. $isMatching = false;
  1526. }
  1527. }
  1528. $columnBefore = $column;
  1529. }
  1530. }
  1531. if ( $strictlyColumns && ( $columns->attributes( 'strict' ) !== 'false' ) && ! $this->checkOtherColumnsExist( $tableName, $allColumns, $columns, $colNamePrefix, $change ) ) {
  1532. $isMatching = false;
  1533. }
  1535. // 2) Check indexes:
  1536. $indexes =& $table->getElementByPath( 'indexes' );
  1537. if ( $indexes !== false ) {
  1538. $allIndexes = $this->getAllTableIndexes( $tableName );
  1539. foreach ( $indexes->children() as $index ) {
  1540. if ( $index->name() == 'index' ) {
  1541. if ( ! $this->checkIndexExistsType( $tableName, $allIndexes, $index, $colNamePrefix, $change ) ) {
  1542. if ( ( ! $change ) || ( ! $this->changeIndex( $tableName, $allIndexes, $index, $colNamePrefix ) ) ) {
  1543. $isMatching = false;
  1544. }
  1545. }
  1546. }
  1547. }
  1548. if ( $strictlyColumns && ( $indexes->attributes( 'strict' ) !== 'false' ) && ! $this->checkOtherIndexesExist( $tableName, $allIndexes, $indexes, $colNamePrefix, $change ) ) {
  1549. $isMatching = false;
  1550. }
  1551. }
  1552. }
  1553. // 3) Now that indexed table is checked (exists or has been created), Check rows:
  1554. if ( $allColumns !== false ) {
  1555. $rows =& $table->getElementByPath( 'rows' );
  1556. if ( $rows !== false ) {
  1557. foreach ( $rows->children() as $row ) {
  1558. if ( $row->name() == 'row' ) {
  1559. $rowArray = null;
  1560. if ( ! $this->checkOrChangeRow( $tableName, $rows, $row, $allColumns, $colNamePrefix, $change ) ) {
  1561. $isMatching = false;
  1562. }
  1563. }
  1564. }
  1565. if ( $strictlyColumns && ( $rows->attributes( 'strict' ) !== 'false' ) && ! $this->checkOtherRowsExist( $tableName, $rows, $colNamePrefix, $change ) ) {
  1566. $isMatching = false;
  1567. }
  1568. }
  1569. }
  1570. }
  1571. }
  1572. return $isMatching;
  1573. }
  1574. /**
  1575.  * Checks if all columns of a xml description of all tables of a database matches the database
  1576.  *
  1577.  * Warning: removes columns tables and columns which would be added by the changes to XML !!!
  1578.  * @access private
  1579.  *
  1580.  * @param  CBSimpleXMLElement  $table
  1581.  * @param  string              $colNamePrefix    Prefix to add to all column names
  1582.  * @param  string              $change           'drop': uninstalls columns/tables
  1583.  * @param  boolean|null        $strictlyColumns  FALSE: allow for other columns, TRUE: doesn't allow for other columns, NULL: checks for attribute 'strict' in table
  1584.  * @return boolean             TRUE: matches, FALSE: don't match
  1585.  */
  1586. function dropXmlTableDescription( &$table, $colNamePrefix = '', $change = 'drop', $strictlyColumns = false ) {
  1587. $isMatching = false;
  1588. if ( $table->name() == 'table' ) {
  1589. $tableName = $this->_prefixedName( $table, $colNamePrefix );
  1590. $columns =& $table->getElementByPath( 'columns' );
  1591. if ( $tableName && ( $columns !== false ) ) {
  1592. if ( $strictlyColumns === null ) {
  1593. $strictlyColumns = ( $table->attributes( 'strict' ) === 'true' );
  1594. }
  1595. $neverDropTable = ( $table->attributes( 'drop' ) === 'never' );
  1596. $isMatching = true;
  1597. $allColumns = $this->getAllTableColumns( $tableName );
  1598. if ( $allColumns === false ) {
  1599. // table doesn't exist: do nothing
  1600. } else {
  1601. if ( $strictlyColumns && ( ! $neverDropTable ) ) {
  1602. if ( in_array( $tableName, array( '#__comprofiler', '#_users', '#__comprofiler_fields' ) ) ) {
  1603. // Safeguard against fatal error in XML file !
  1604. $errorMsg = sprintf( 'Fatal error: Trying to delete core CB table %s not allowed.', $tableName );
  1605. echo $errorMsg;
  1606. trigger_error( $errorMsg, E_USER_ERROR );
  1607. exit;
  1608. }
  1609. $this->dropTable( $tableName );
  1610. } else {
  1611. // 1) Drop rows:
  1612. $rows =& $table->getElementByPath( 'rows' );
  1613. if ( $rows !== false ) {
  1614. $neverDropRows = ( $rows->attributes( 'drop' ) === 'never' );
  1615. if ( ! $neverDropRows ) {
  1616. $strictRows = ( ( $rows->attributes( 'strict' ) === 'true' ) );
  1617. foreach ( $rows->children() as $row ) {
  1618. if ( $row->name() == 'row' ) {
  1619. $neverDropRow = ( $row->attributes( 'drop' ) === 'never' );
  1620. if ( ( $strictRows && ! $neverDropRow ) ) {
  1621. if ( ! $this->dropRow( $tableName, $row, $colNamePrefix ) ) {
  1622. $isMatching = false;
  1623. }
  1624. }
  1625. }
  1626. }
  1627. }
  1628. }
  1629. // 2) Drop indexes:
  1630. $indexes =& $table->getElementByPath( 'indexes' );
  1631. if ( $indexes !== false ) {
  1632. $neverDropIndexes = ( $indexes->attributes( 'drop' ) === 'never' );
  1633. if ( ! $neverDropIndexes ) {
  1634. $allIndexes = $this->getAllTableIndexes( $tableName );
  1635. foreach ( $indexes->children() as $index ) {
  1636. if ( $index->name() == 'index' ) {
  1637. $indexName = $this->_prefixedName( $index, $colNamePrefix );
  1638. if ( $indexName == 'PRIMARY' ) {
  1639. $neverDropIndex = ( $index->attributes( 'drop' ) !== 'always' );
  1640. } else {
  1641. $neverDropIndex = ( $index->attributes( 'drop' ) === 'never' );
  1642. }
  1643. if ( isset( $allIndexes[$indexName] ) && ! $neverDropIndex ) {
  1644. if ( ! $this->dropIndex( $tableName, $indexName ) ) {
  1645. $isMatching = false;
  1646. }
  1647. }
  1648. }
  1649. }
  1650. }
  1651. }
  1652. // 3) Drop columns:
  1653. $neverDropColumns = ( $columns->attributes( 'drop' ) === 'never' );
  1654. if ( ! $neverDropColumns ) {
  1655. foreach ( $columns->children() as $column ) {
  1656. if ( $column->name() == 'column' ) {
  1657. $neverDropColumn = ( $column->attributes( 'drop' ) === 'never' );
  1658. $colNamePrefixed = $this->_prefixedName( $column, $colNamePrefix );
  1659. if ( isset( $allColumns[$colNamePrefixed] ) && ! $neverDropColumn ) {
  1660. if ( ! $this->dropColumn( $tableName, $colNamePrefixed ) ) {
  1661. $isMatching = false;
  1662. }
  1663. }
  1664. }
  1665. }
  1666. }
  1667. }
  1668. }
  1669. }
  1670. }
  1671. return $isMatching;
  1672. }
  1673. /**
  1674.  * Checks if all columns of a xml description of all tables of a database matches the database
  1675.  *
  1676.  * Warning: if ( $change && $strictlyColumns ) it will DROP not described columns !!!
  1677.  * @access private
  1678.  *
  1679.  * @param  string|array        $tablesNames      Name(s) of tables to dump
  1680.  * @param  boolean             $withContent      FALSE: only structure, TRUE: also content
  1681.  * @return CBSimpleXMLElement
  1682.  */
  1683. function dumpTableToXml( $tablesNames, $withContent = true ) {
  1684. $db = new CBSimpleXMLElement( '<?xml version="1.0" encoding="UTF-8"?><database version="1" />' );
  1686. foreach ( (array) $tablesNames as $tableName ) {
  1688. $table = $db->addChild( 'table' );
  1689. $table->addAttribute( 'name', $tableName );
  1690. $table->addAttribute( 'class', '' );
  1691. $table->addAttribute( 'strict', 'false' );
  1692. $table->addAttribute( 'drop', 'never' );
  1694. // Columns:
  1696. $allColumns = $this->getAllTableColumns( $tableName );
  1698. $columns = $table->addChild( 'columns' );
  1699. foreach ( $allColumns as $colEntry ) {
  1700. $colTypeUnsigned = explode( ' ', $colEntry->Type );
  1701. if ( count( $colTypeUnsigned ) == 1 ) {
  1702. $colTypeUnsigned[1] = null;
  1703. }
  1704. $column = $columns->addChild( 'column' );
  1705. $column->addAttribute( 'name',  $colEntry->Field );
  1706. $column->addAttribute( 'type', 'sql:' . $colTypeUnsigned[0] );
  1707. if ( $colTypeUnsigned[1] === 'unsigned' ) {
  1708. $column->addAttribute( 'unsigned', ( $colTypeUnsigned[1] === 'unsigned' ? 'true' : 'false' ) );
  1709. }
  1710. if ( $colEntry->Null === 'YES' ) {
  1711. $column->addAttribute( 'null', ( $colEntry->Null === 'YES' ? 'true' : 'false' ) );
  1712. }
  1713. if ( $colEntry->Default !== null ) {
  1714. if ( $colEntry->Null === 'YES' ) {
  1715. $column->addAttribute( 'default', $colEntry->Default );
  1716. } else {
  1717. $defaultDefaultTypes = $this->defaultValuesOfTypes( $this->mysqlToXmlsql( 'sql:' . $colTypeUnsigned[0] ) );
  1718. if ( ! in_array( $colEntry->Default, $defaultDefaultTypes ) ) {
  1719. $column->addAttribute( 'default', $colEntry->Default );
  1720. }
  1721. }
  1722. }
  1723. if ( strpos( $colEntry->Extra, 'auto_increment' ) !== false ) {
  1724. $tableStatus = $this->_db->getTableStatus( $tableName );
  1725. if ( isset( $tableStatus[0]->Auto_increment ) ) {
  1726. $lastAuto_increment = $tableStatus[0]->Auto_increment;
  1727. } else {
  1728. $lastAuto_increment = '100';
  1729. }
  1730. $column->addAttribute( 'auto_increment', $lastAuto_increment );
  1731. }
  1732. }
  1734. // Indexes:
  1736. $indexes = $table->addChild( 'indexes' );
  1738. $primaryIndex = null;
  1740. $allIndexes = $this->getAllTableIndexes( $tableName );
  1742. foreach ( $allIndexes as $indexName => $sequenceInIndexArray ) {
  1743. $type = $sequenceInIndexArray[1]['type'];
  1744. $using = $sequenceInIndexArray[1]['using'];
  1746. $index = $indexes->addChild( 'index' );
  1747. $index->addAttribute( 'name', $indexName );
  1748. if ( $type != '' ) {
  1749. $index->addAttribute( 'type', $type );
  1750. }
  1751. if ( $using != 'btree' ) {
  1752. $index->addAttribute( 'using', $using );
  1753. }
  1754. foreach ( $sequenceInIndexArray as $sequenceInIndex => $indexAttributes ) {
  1755. $column = $index->addChild( 'column' );
  1756. $column->addAttribute( 'name', $indexAttributes['name'] );
  1757. if ( $indexAttributes['size'] ) {
  1758. $column->addAttribute( 'size', $indexAttributes['size'] );
  1759. }
  1760. if ( $indexAttributes['ordering'] != 'A' ) {
  1761. $column->addAttribute( 'ordering', $indexAttributes['ordering'] );
  1762. }
  1763. }
  1764. if ( $type == 'primary' ) {
  1765. $primaryIndex = $index;
  1766. }
  1767. }
  1769. // Content:
  1771. if ( $withContent ) {
  1772. $allRows = $this->loadRows( $tableName, null, null, null );
  1773. if ( count( $allRows ) > 0 ) {
  1774. $rows = $table->addChild( 'rows' );
  1776. $primaryNames = null;
  1777. if ( $primaryIndex !== null ) {
  1778. foreach ( $primaryIndex->children() as $column ) {
  1779. if ( $column->name() == 'column' ) {
  1780. $primaryNames[] = $column->attributes( 'name' );
  1781. }
  1782. }
  1783. }
  1785. foreach ( $allRows as $rowData ) {
  1786. $row = $rows->addChild( 'row' );
  1787. // missing primary key here:
  1788. $rowIndexName = array();
  1789. $rowIndexValue = array();
  1790. $rowIndexValueType = array();
  1791. foreach ( get_object_vars( $rowData ) as $fieldDataName => $fieldDataValue ) {
  1792. if ( $fieldDataName[0] != '_' ) {
  1793. $typeColumn = $columns->getChildByNameAttributes( 'column', array( 'name' => $fieldDataName ) );
  1794. $fieldDataValueType = 'const:' . $this->mysqlToXmlsql( $typeColumn->attributes( 'type' ) );
  1795. $field = $row->addChild( 'field' );
  1796. if ( $fieldDataValue === null ) {
  1797. $fieldDataValue = 'NULL';
  1798. $fieldDataValueType = 'const:null';
  1799. }
  1800. $field->addAttribute( 'name', $fieldDataName );
  1801. $field->addAttribute( 'value', $fieldDataValue );
  1802. $field->addAttribute( 'valuetype', $fieldDataValueType );
  1803. if ( in_array( $fieldDataName, $primaryNames ) ) {
  1804. $field->addAttribute( 'strict', 'true' );
  1805. $rowIndexName[] = $fieldDataName;
  1806. $rowIndexValue[] = $fieldDataValue;
  1807. $rowIndexValueType[] = $fieldDataValueType;
  1808. }
  1809. }
  1810. }
  1811. $row->addAttribute( 'index',  implode( ' ', $rowIndexName ) );
  1812. $row->addAttribute( 'value',  implode( ' ', $rowIndexValue ) );
  1813. $row->addAttribute( 'valuetype', implode( ' ', $rowIndexValueType ) );
  1814. }
  1815. }
  1816. }
  1817. }
  1818. return $db;
  1819. }
  1820. /**
  1821.  * Main function FOR CB INTERNAL USE ONLY:
  1822.  */
  1824. /**
  1825.  * Checks if all columns of a xml description of all tables of a database matches the database
  1826.  *
  1827.  * Warning: if ( $change && $strictlyColumns ) it will DROP not described columns !!!
  1828.  *
  1829.  *  <database version="1">
  1830.  * <table name="#__comprofiler" class="moscomprofiler">
  1831.  * <columns>
  1832.  * <column name="_rate" nametype="namesuffix" type="sql:decimal(16,8)" unsigned="true" null="true" default="NULL" auto_increment="100" />
  1833.  * <table name="#__comprofiler_hf2_" nametype="nameprefix" class="myClass" strict="true">
  1834.  * <indexes>
  1835.  * <index name="primary" type="primary">
  1836.  * <column name="id" />
  1837.  * </index>
  1838.  * <index name="rate_chars">
  1839.  * <column name="rate" />
  1840.  * <column name="_mychars" nametype="namesuffix" size="8" ordering="ASC" />
  1841.  * </index>
  1842.  * <index name="chars_rate_id" type="unique" using="btree">
  1843.  *
  1844.  * @param  CBSimpleXMLElement  $xml
  1845.  * @param  string              $colNamePrefix    Prefix to add to all column names
  1846.  * @param  boolean|string      $change           FALSE: only check, TRUE: change database to match description (deleting non-matching columns if $strictlyColumns == true), 'drop': uninstalls columns/tables
  1847.  * @param  boolean             $strictlyColumns  FALSE: allow for other columns, TRUE: doesn't allow for other columns
  1848.  * @return boolean             TRUE: matches, FALSE: don't match
  1849.  */
  1850. function checkXmlDatabaseDescription( &$db, $colNamePrefix = '', $change = false, $strictlyColumns = false ) {
  1851. $isMatching = false;
  1852. if ( $db->name() == 'database' ) {
  1853. $isMatching = true;
  1854. foreach ( $db->children() as $table ) {
  1855. if ( $table->name() == 'table' ) {
  1856. if ( is_bool( $change ) ) {
  1857. $isMatching = $this->checkXmlTableDescription( $table, $colNamePrefix, $change, $strictlyColumns ) && $isMatching;
  1858. } else {
  1859. $isMatching = $this->dropXmlTableDescription( $table, $colNamePrefix, $change, $strictlyColumns ) && $isMatching;
  1860. }
  1861. }
  1862. }
  1863. }
  1864. return $isMatching;
  1865. }
  1866. /**
  1867.  * Returns main table name (pre/post/fixed with $colNamePrefix)
  1868.  *
  1869.  * <database>
  1870.  *  <table name="xyz" nametype="nameprefix" maintable="true">
  1871.  *
  1872.  * @param  CBSimpleXMLElement  $db
  1873.  * @param  string              $colNamePrefix    Prefix to add to all column names
  1874.  * @param  string|null         $default          Default table result to return if table not found in xml
  1875.  * @return string
  1876.  */
  1877. function getMainTableName( &$db, $colNamePrefix = '', $default = null ) {
  1878. $maintable =& $db->getChildByNameAttr( 'table', 'maintable', 'true' );
  1879. if ( $maintable !== false ) {
  1880. return $this->_prefixedName( $maintable, $colNamePrefix );
  1881. }
  1882. return $default;
  1883. }
  1884. /**
  1885.  * Returns array of column names (pre/post/fixed with $colNamePrefix) of $table
  1886.  *
  1887.  * @param  CBSimpleXMLElement  $db
  1888.  * @param  string              $colNamePrefix    Prefix to add to all column names
  1889.  * @return array|boolean                         False if not found
  1890.  */
  1891. function getMainTableColumnsNames( &$db, $colNamePrefix = '' ) {
  1892. $table =& $db->getChildByNameAttr( 'table', 'maintable', 'true' );
  1893. if ( $table !== false ) {
  1894. $columns =& $table->getElementByPath( 'columns' );
  1895. if ( $columns !== false ) {
  1896. $columnNamesArray = array();
  1897. foreach ( $columns->children() as $column ) {
  1898. if ( $column->name() == 'column' ) {
  1899. $columnNamesArray[] = $this->_prefixedName( $column, $colNamePrefix );
  1900. }
  1901. }
  1902. return $columnNamesArray;
  1903. }
  1904. }
  1905. return false;
  1906. }
  1907. } // class CBSQLupgrader
  1909. ?>