gacl/adodb/adodb-xmlschema03.inc.php

   1 <?php
   2 // Copyright (c) 2004-2005 ars Cognita Inc., all rights reserved
   3 /* ******************************************************************************
   4     Released under both BSD license and Lesser GPL library license.
   5         Whenever there is any discrepancy between the two licenses,
   6         the BSD license will take precedence.
   7 *******************************************************************************/
   8 /**
   9  * xmlschema is a class that allows the user to quickly and easily
  10  * build a database on any ADOdb-supported platform using a simple
  11  * XML schema.
  12  *
  13  * Last Editor: $Author$
  14  * @author Richard Tango-Lowy & Dan Cech
  15  * @version $Revision$
  16  *
  17  * @package axmls
  18  * @tutorial getting_started.pkg
  19  */
  20
  21 function _file_get_contents($file)
  22 {
  23         if (function_exists('file_get_contents')) return file_get_contents($file);
  24
  25         $f = fopen($file,'r');
  26         if (!$f) return '';
  27         $t = '';
  28
  29         while ($s = fread($f,100000)) $t .= $s;
  30         fclose($f);
  31         return $t;
  32 }
  33
  34
  35 /**
  36 * Debug on or off
  37 */
  38 if( !defined( 'XMLS_DEBUG' ) ) {
  39         define( 'XMLS_DEBUG', FALSE );
  40 }
  41
  42 /**
  43 * Default prefix key
  44 */
  45 if( !defined( 'XMLS_PREFIX' ) ) {
  46         define( 'XMLS_PREFIX', '%%P' );
  47 }
  48
  49 /**
  50 * Maximum length allowed for object prefix
  51 */
  52 if( !defined( 'XMLS_PREFIX_MAXLEN' ) ) {
  53         define( 'XMLS_PREFIX_MAXLEN', 10 );
  54 }
  55
  56 /**
  57 * Execute SQL inline as it is generated
  58 */
  59 if( !defined( 'XMLS_EXECUTE_INLINE' ) ) {
  60         define( 'XMLS_EXECUTE_INLINE', FALSE );
  61 }
  62
  63 /**
  64 * Continue SQL Execution if an error occurs?
  65 */
  66 if( !defined( 'XMLS_CONTINUE_ON_ERROR' ) ) {
  67         define( 'XMLS_CONTINUE_ON_ERROR', FALSE );
  68 }
  69
  70 /**
  71 * Current Schema Version
  72 */
  73 if( !defined( 'XMLS_SCHEMA_VERSION' ) ) {
  74         define( 'XMLS_SCHEMA_VERSION', '0.3' );
  75 }
  76
  77 /**
  78 * Default Schema Version.  Used for Schemas without an explicit version set.
  79 */
  80 if( !defined( 'XMLS_DEFAULT_SCHEMA_VERSION' ) ) {
  81         define( 'XMLS_DEFAULT_SCHEMA_VERSION', '0.1' );
  82 }
  83
  84 /**
  85 * How to handle data rows that already exist in a database during and upgrade.
  86 * Options are INSERT (attempts to insert duplicate rows), UPDATE (updates existing
  87 * rows) and IGNORE (ignores existing rows).
  88 */
  89 if( !defined( 'XMLS_MODE_INSERT' ) ) {
  90         define( 'XMLS_MODE_INSERT', 0 );
  91 }
  92 if( !defined( 'XMLS_MODE_UPDATE' ) ) {
  93         define( 'XMLS_MODE_UPDATE', 1 );
  94 }
  95 if( !defined( 'XMLS_MODE_IGNORE' ) ) {
  96         define( 'XMLS_MODE_IGNORE', 2 );
  97 }
  98 if( !defined( 'XMLS_EXISTING_DATA' ) ) {
  99         define( 'XMLS_EXISTING_DATA', XMLS_MODE_INSERT );
 100 }
 101
 102 /**
 103 * Default Schema Version.  Used for Schemas without an explicit version set.
 104 */
 105 if( !defined( 'XMLS_DEFAULT_UPGRADE_METHOD' ) ) {
 106         define( 'XMLS_DEFAULT_UPGRADE_METHOD', 'ALTER' );
 107 }
 108
 109 /**
 110 * Include the main ADODB library
 111 */
 112 if( !defined( '_ADODB_LAYER' ) ) {
 113         require( 'adodb.inc.php' );
 114         require( 'adodb-datadict.inc.php' );
 115 }
 116
 117 /**
 118 * Abstract DB Object. This class provides basic methods for database objects, such
 119 * as tables and indexes.
 120 *
 121 * @package axmls
 122 * @access private
 123 */
 124 class dbObject {
 125
 126         /**
 127         * var object Parent
 128         */
 129         var $parent;
 130
 131         /**
 132         * var string current element
 133         */
 134         var $currentElement;
 135
 136         /**
 137         * NOP
 138         */
 139         function dbObject( &$parent, $attributes = NULL ) {
 140                 $this->parent =& $parent;
 141         }
 142
 143         /**
 144         * XML Callback to process start elements
 145         *
 146         * @access private
 147         */
 148         function _tag_open( &$parser, $tag, $attributes ) {
 149
 150         }
 151
 152         /**
 153         * XML Callback to process CDATA elements
 154         *
 155         * @access private
 156         */
 157         function _tag_cdata( &$parser, $cdata ) {
 158
 159         }
 160
 161         /**
 162         * XML Callback to process end elements
 163         *
 164         * @access private
 165         */
 166         function _tag_close( &$parser, $tag ) {
 167
 168         }
 169
 170         function create() {
 171                 return array();
 172         }
 173
 174         /**
 175         * Destroys the object
 176         */
 177         function destroy() {
 178                 unset( $this );
 179         }
 180
 181         /**
 182         * Checks whether the specified RDBMS is supported by the current
 183         * database object or its ranking ancestor.
 184         *
 185         * @param string $platform RDBMS platform name (from ADODB platform list).
 186         * @return boolean TRUE if RDBMS is supported; otherwise returns FALSE.
 187         */
 188         function supportedPlatform( $platform = NULL ) {
 189                 return is_object( $this->parent ) ? $this->parent->supportedPlatform( $platform ) : TRUE;
 190         }
 191
 192         /**
 193         * Returns the prefix set by the ranking ancestor of the database object.
 194         *
 195         * @param string $name Prefix string.
 196         * @return string Prefix.
 197         */
 198         function prefix( $name = '' ) {
 199                 return is_object( $this->parent ) ? $this->parent->prefix( $name ) : $name;
 200         }
 201
 202         /**
 203         * Extracts a field ID from the specified field.
 204         *
 205         * @param string $field Field.
 206         * @return string Field ID.
 207         */
 208         function FieldID( $field ) {
 209                 return strtoupper( preg_replace( '/^`(.+)`$/', '$1', $field ) );
 210         }
 211 }
 212
 213 /**
 214 * Creates a table object in ADOdb's datadict format
 215 *
 216 * This class stores information about a database table. As charactaristics
 217 * of the table are loaded from the external source, methods and properties
 218 * of this class are used to build up the table description in ADOdb's
 219 * datadict format.
 220 *
 221 * @package axmls
 222 * @access private
 223 */
 224 class dbTable extends dbObject {
 225
 226         /**
 227         * @var string Table name
 228         */
 229         var $name;
 230
 231         /**
 232         * @var array Field specifier: Meta-information about each field
 233         */
 234         var $fields = array();
 235
 236         /**
 237         * @var array List of table indexes.
 238         */
 239         var $indexes = array();
 240
 241         /**
 242         * @var array Table options: Table-level options
 243         */
 244         var $opts = array();
 245
 246         /**
 247         * @var string Field index: Keeps track of which field is currently being processed
 248         */
 249         var $current_field;
 250
 251         /**
 252         * @var boolean Mark table for destruction
 253         * @access private
 254         */
 255         var $drop_table;
 256
 257         /**
 258         * @var boolean Mark field for destruction (not yet implemented)
 259         * @access private
 260         */
 261         var $drop_field = array();
 262
 263         /**
 264         * @var array Platform-specific options
 265         * @access private
 266         */
 267         var $currentPlatform = true;
 268
 269
 270         /**
 271         * Iniitializes a new table object.
 272         *
 273         * @param string $prefix DB Object prefix
 274         * @param array $attributes Array of table attributes.
 275         */
 276         function dbTable( &$parent, $attributes = NULL ) {
 277                 $this->parent =& $parent;
 278                 $this->name = $this->prefix($attributes['NAME']);
 279         }
 280
 281         /**
 282         * XML Callback to process start elements. Elements currently
 283         * processed are: INDEX, DROP, FIELD, KEY, NOTNULL, AUTOINCREMENT & DEFAULT.
 284         *
 285         * @access private
 286         */
 287         function _tag_open( &$parser, $tag, $attributes ) {
 288                 $this->currentElement = strtoupper( $tag );
 289
 290                 switch( $this->currentElement ) {
 291                         case 'INDEX':
 292                                 if( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) ) {
 293                                         xml_set_object( $parser, $this->addIndex( $attributes ) );
 294                                 }
 295                                 break;
 296                         case 'DATA':
 297                                 if( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) ) {
 298                                         xml_set_object( $parser, $this->addData( $attributes ) );
 299                                 }
 300                                 break;
 301                         case 'DROP':
 302                                 $this->drop();
 303                                 break;
 304                         case 'FIELD':
 305                                 // Add a field
 306                                 $fieldName = $attributes['NAME'];
 307                                 $fieldType = $attributes['TYPE'];
 308                                 $fieldSize = isset( $attributes['SIZE'] ) ? $attributes['SIZE'] : NULL;
 309                                 $fieldOpts = !empty( $attributes['OPTS'] ) ? $attributes['OPTS'] : NULL;
 310
 311                                 $this->addField( $fieldName, $fieldType, $fieldSize, $fieldOpts );
 312                                 break;
 313                         case 'KEY':
 314                         case 'NOTNULL':
 315                         case 'AUTOINCREMENT':
 316                         case 'DEFDATE':
 317                         case 'DEFTIMESTAMP':
 318                         case 'UNSIGNED':
 319                                 // Add a field option
 320                                 $this->addFieldOpt( $this->current_field, $this->currentElement );
 321                                 break;
 322                         case 'DEFAULT':
 323                                 // Add a field option to the table object
 324
 325                                 // Work around ADOdb datadict issue that misinterprets empty strings.
 326                                 if( $attributes['VALUE'] == '' ) {
 327                                         $attributes['VALUE'] = " '' ";
 328                                 }
 329
 330                                 $this->addFieldOpt( $this->current_field, $this->currentElement, $attributes['VALUE'] );
 331                                 break;
 332                         case 'OPT':
 333                         case 'CONSTRAINT':
 334                                 // Accept platform-specific options
 335                                 $this->currentPlatform = ( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) );
 336                                 break;
 337                         default:
 338                                 // print_r( array( $tag, $attributes ) );
 339                 }
 340         }
 341
 342         /**
 343         * XML Callback to process CDATA elements
 344         *
 345         * @access private
 346         */
 347         function _tag_cdata( &$parser, $cdata ) {
 348                 switch( $this->currentElement ) {
 349                         // Table/field constraint
 350                         case 'CONSTRAINT':
 351                                 if( isset( $this->current_field ) ) {
 352                                         $this->addFieldOpt( $this->current_field, $this->currentElement, $cdata );
 353                                 } else {
 354                                         $this->addTableOpt( $cdata );
 355                                 }
 356                                 break;
 357                         // Table/field option
 358                         case 'OPT':
 359                                 if( isset( $this->current_field ) ) {
 360                                         $this->addFieldOpt( $this->current_field, $cdata );
 361                                 } else {
 362                                 $this->addTableOpt( $cdata );
 363                                 }
 364                                 break;
 365                         default:
 366
 367                 }
 368         }
 369
 370         /**
 371         * XML Callback to process end elements
 372         *
 373         * @access private
 374         */
 375         function _tag_close( &$parser, $tag ) {
 376                 $this->currentElement = '';
 377
 378                 switch( strtoupper( $tag ) ) {
 379                         case 'TABLE':
 380                                 $this->parent->addSQL( $this->create( $this->parent ) );
 381                                 xml_set_object( $parser, $this->parent );
 382                                 $this->destroy();
 383                                 break;
 384                         case 'FIELD':
 385                                 unset($this->current_field);
 386                                 break;
 387                         case 'OPT':
 388                         case 'CONSTRAINT':
 389                                 $this->currentPlatform = true;
 390                                 break;
 391                         default:
 392
 393                 }
 394         }
 395
 396         /**
 397         * Adds an index to a table object
 398         *
 399         * @param array $attributes Index attributes
 400         * @return object dbIndex object
 401         */
 402         function &addIndex( $attributes ) {
 403                 $name = strtoupper( $attributes['NAME'] );
 404                 $this->indexes[$name] =& new dbIndex( $this, $attributes );
 405                 return $this->indexes[$name];
 406         }
 407
 408         /**
 409         * Adds data to a table object
 410         *
 411         * @param array $attributes Data attributes
 412         * @return object dbData object
 413         */
 414         function &addData( $attributes ) {
 415                 if( !isset( $this->data ) ) {
 416                         $this->data =& new dbData( $this, $attributes );
 417                 }
 418                 return $this->data;
 419         }
 420
 421         /**
 422         * Adds a field to a table object
 423         *
 424         * $name is the name of the table to which the field should be added.
 425         * $type is an ADODB datadict field type. The following field types
 426         * are supported as of ADODB 3.40:
 427         *       - C:  varchar
 428         *       - X:  CLOB (character large object) or largest varchar size
 429         *          if CLOB is not supported
 430         *       - C2: Multibyte varchar
 431         *       - X2: Multibyte CLOB
 432         *       - B:  BLOB (binary large object)
 433         *       - D:  Date (some databases do not support this, and we return a datetime type)
 434         *       - T:  Datetime or Timestamp
 435         *       - L:  Integer field suitable for storing booleans (0 or 1)
 436         *       - I:  Integer (mapped to I4)
 437         *       - I1: 1-byte integer
 438         *       - I2: 2-byte integer
 439         *       - I4: 4-byte integer
 440         *       - I8: 8-byte integer
 441         *       - F:  Floating point number
 442         *       - N:  Numeric or decimal number
 443         *
 444         * @param string $name Name of the table to which the field will be added.
 445         * @param string $type   ADODB datadict field type.
 446         * @param string $size   Field size
 447         * @param array $opts    Field options array
 448         * @return array Field specifier array
 449         */
 450         function addField( $name, $type, $size = NULL, $opts = NULL ) {
 451                 $field_id = $this->FieldID( $name );
 452
 453                 // Set the field index so we know where we are
 454                 $this->current_field = $field_id;
 455
 456                 // Set the field name (required)
 457                 $this->fields[$field_id]['NAME'] = $name;
 458
 459                 // Set the field type (required)
 460                 $this->fields[$field_id]['TYPE'] = $type;
 461
 462                 // Set the field size (optional)
 463                 if( isset( $size ) ) {
 464                         $this->fields[$field_id]['SIZE'] = $size;
 465                 }
 466
 467                 // Set the field options
 468                 if( isset( $opts ) ) {
 469                         $this->fields[$field_id]['OPTS'] = array($opts);
 470                 } else {
 471                         $this->fields[$field_id]['OPTS'] = array();
 472                 }
 473         }
 474
 475         /**
 476         * Adds a field option to the current field specifier
 477         *
 478         * This method adds a field option allowed by the ADOdb datadict
 479         * and appends it to the given field.
 480         *
 481         * @param string $field  Field name
 482         * @param string $opt ADOdb field option
 483         * @param mixed $value Field option value
 484         * @return array Field specifier array
 485         */
 486         function addFieldOpt( $field, $opt, $value = NULL ) {
 487                 if( $this->currentPlatform ) {
 488                 if( !isset( $value ) ) {
 489                         $this->fields[$this->FieldID( $field )]['OPTS'][] = $opt;
 490                 // Add the option and value
 491                 } else {
 492                         $this->fields[$this->FieldID( $field )]['OPTS'][] = array( $opt => $value );
 493                 }
 494         }
 495         }
 496
 497         /**
 498         * Adds an option to the table
 499         *
 500         * This method takes a comma-separated list of table-level options
 501         * and appends them to the table object.
 502         *
 503         * @param string $opt Table option
 504         * @return array Options
 505         */
 506         function addTableOpt( $opt ) {
 507                 if( $this->currentPlatform ) {
 508                 $this->opts[] = $opt;
 509                 }
 510                 return $this->opts;
 511         }
 512
 513         /**
 514         * Generates the SQL that will create the table in the database
 515         *
 516         * @param object $xmls adoSchema object
 517         * @return array Array containing table creation SQL
 518         */
 519         function create( &$xmls ) {
 520                 $sql = array();
 521
 522                 // drop any existing indexes
 523                 if( is_array( $legacy_indexes = $xmls->dict->MetaIndexes( $this->name ) ) ) {
 524                         foreach( $legacy_indexes as $index => $index_details ) {
 525                                 $sql[] = $xmls->dict->DropIndexSQL( $index, $this->name );
 526                         }
 527                 }
 528
 529                 // remove fields to be dropped from table object
 530                 foreach( $this->drop_field as $field ) {
 531                         unset( $this->fields[$field] );
 532                 }
 533
 534                 // if table exists
 535                 if( is_array( $legacy_fields = $xmls->dict->MetaColumns( $this->name ) ) ) {
 536                         // drop table
 537                         if( $this->drop_table ) {
 538                                 $sql[] = $xmls->dict->DropTableSQL( $this->name );
 539
 540                                 return $sql;
 541                         }
 542
 543                         // drop any existing fields not in schema
 544                         foreach( $legacy_fields as $field_id => $field ) {
 545                                 if( !isset( $this->fields[$field_id] ) ) {
 546                                         $sql[] = $xmls->dict->DropColumnSQL( $this->name, $field->name );
 547                                 }
 548                         }
 549                 // if table doesn't exist
 550                 } else {
 551                         if( $this->drop_table ) {
 552                                 return $sql;
 553                         }
 554
 555                         $legacy_fields = array();
 556                 }
 557
 558                 // Loop through the field specifier array, building the associative array for the field options
 559                 $fldarray = array();
 560
 561                 foreach( $this->fields as $field_id => $finfo ) {
 562                         // Set an empty size if it isn't supplied
 563                         if( !isset( $finfo['SIZE'] ) ) {
 564                                 $finfo['SIZE'] = '';
 565                         }
 566
 567                         // Initialize the field array with the type and size
 568                         $fldarray[$field_id] = array(
 569                                 'NAME' => $finfo['NAME'],
 570                                 'TYPE' => $finfo['TYPE'],
 571                                 'SIZE' => $finfo['SIZE']
 572                         );
 573
 574                         // Loop through the options array and add the field options.
 575                         if( isset( $finfo['OPTS'] ) ) {
 576                                 foreach( $finfo['OPTS'] as $opt ) {
 577                                         // Option has an argument.
 578                                         if( is_array( $opt ) ) {
 579                                                 $key = key( $opt );
 580                                                 $value = $opt[key( $opt )];
 581                                                 @$fldarray[$field_id][$key] .= $value;
 582                                         // Option doesn't have arguments
 583                                         } else {
 584                                                 $fldarray[$field_id][$opt] = $opt;
 585                                         }
 586                                 }
 587                         }
 588                 }
 589
 590                 if( empty( $legacy_fields ) ) {
 591                         // Create the new table
 592                         $sql[] = $xmls->dict->CreateTableSQL( $this->name, $fldarray, $this->opts );
 593                         logMsg( end( $sql ), 'Generated CreateTableSQL' );
 594                 } else {
 595                         // Upgrade an existing table
 596                         logMsg( "Upgrading {$this->name} using '{$xmls->upgrade}'" );
 597                         switch( $xmls->upgrade ) {
 598                                 // Use ChangeTableSQL
 599                                 case 'ALTER':
 600                                         logMsg( 'Generated ChangeTableSQL (ALTERing table)' );
 601                                         $sql[] = $xmls->dict->ChangeTableSQL( $this->name, $fldarray, $this->opts );
 602                                         break;
 603                                 case 'REPLACE':
 604                                         logMsg( 'Doing upgrade REPLACE (testing)' );
 605                                         $sql[] = $xmls->dict->DropTableSQL( $this->name );
 606                                         $sql[] = $xmls->dict->CreateTableSQL( $this->name, $fldarray, $this->opts );
 607                                         break;
 608                                 // ignore table
 609                                 default:
 610                                         return array();
 611                         }
 612                 }
 613
 614                 foreach( $this->indexes as $index ) {
 615                         $sql[] = $index->create( $xmls );
 616                 }
 617
 618                 if( isset( $this->data ) ) {
 619                         $sql[] = $this->data->create( $xmls );
 620                 }
 621
 622                 return $sql;
 623         }
 624
 625         /**
 626         * Marks a field or table for destruction
 627         */
 628         function drop() {
 629                 if( isset( $this->current_field ) ) {
 630                         // Drop the current field
 631                         logMsg( "Dropping field '{$this->current_field}' from table '{$this->name}'" );
 632                         // $this->drop_field[$this->current_field] = $xmls->dict->DropColumnSQL( $this->name, $this->current_field );
 633                         $this->drop_field[$this->current_field] = $this->current_field;
 634                 } else {
 635                         // Drop the current table
 636                         logMsg( "Dropping table '{$this->name}'" );
 637                         // $this->drop_table = $xmls->dict->DropTableSQL( $this->name );
 638                         $this->drop_table = TRUE;
 639                 }
 640         }
 641 }
 642
 643 /**
 644 * Creates an index object in ADOdb's datadict format
 645 *
 646 * This class stores information about a database index. As charactaristics
 647 * of the index are loaded from the external source, methods and properties
 648 * of this class are used to build up the index description in ADOdb's
 649 * datadict format.
 650 *
 651 * @package axmls
 652 * @access private
 653 */
 654 class dbIndex extends dbObject {
 655
 656         /**
 657         * @var string   Index name
 658         */
 659         var $name;
 660
 661         /**
 662         * @var array    Index options: Index-level options
 663         */
 664         var $opts = array();
 665
 666         /**
 667         * @var array    Indexed fields: Table columns included in this index
 668         */
 669         var $columns = array();
 670
 671         /**
 672         * @var boolean Mark index for destruction
 673         * @access private
 674         */
 675         var $drop = FALSE;
 676
 677         /**
 678         * Initializes the new dbIndex object.
 679         *
 680         * @param object $parent Parent object
 681         * @param array $attributes Attributes
 682         *
 683         * @internal
 684         */
 685         function dbIndex( &$parent, $attributes = NULL ) {
 686                 $this->parent =& $parent;
 687
 688                 $this->name = $this->prefix ($attributes['NAME']);
 689         }
 690
 691         /**
 692         * XML Callback to process start elements
 693         *
 694         * Processes XML opening tags.
 695         * Elements currently processed are: DROP, CLUSTERED, BITMAP, UNIQUE, FULLTEXT & HASH.
 696         *
 697         * @access private
 698         */
 699         function _tag_open( &$parser, $tag, $attributes ) {
 700                 $this->currentElement = strtoupper( $tag );
 701
 702                 switch( $this->currentElement ) {
 703                         case 'DROP':
 704                                 $this->drop();
 705                                 break;
 706                         case 'CLUSTERED':
 707                         case 'BITMAP':
 708                         case 'UNIQUE':
 709                         case 'FULLTEXT':
 710                         case 'HASH':
 711                                 // Add index Option
 712                                 $this->addIndexOpt( $this->currentElement );
 713                                 break;
 714                         default:
 715                                 // print_r( array( $tag, $attributes ) );
 716                 }
 717         }
 718
 719         /**
 720         * XML Callback to process CDATA elements
 721         *
 722         * Processes XML cdata.
 723         *
 724         * @access private
 725         */
 726         function _tag_cdata( &$parser, $cdata ) {
 727                 switch( $this->currentElement ) {
 728                         // Index field name
 729                         case 'COL':
 730                                 $this->addField( $cdata );
 731                                 break;
 732                         default:
 733
 734                 }
 735         }
 736
 737         /**
 738         * XML Callback to process end elements
 739         *
 740         * @access private
 741         */
 742         function _tag_close( &$parser, $tag ) {
 743                 $this->currentElement = '';
 744
 745                 switch( strtoupper( $tag ) ) {
 746                         case 'INDEX':
 747                                 xml_set_object( $parser, $this->parent );
 748                                 break;
 749                 }
 750         }
 751
 752         /**
 753         * Adds a field to the index
 754         *
 755         * @param string $name Field name
 756         * @return string Field list
 757         */
 758         function addField( $name ) {
 759                 $this->columns[$this->FieldID( $name )] = $name;
 760
 761                 // Return the field list
 762                 return $this->columns;
 763         }
 764
 765         /**
 766         * Adds options to the index
 767         *
 768         * @param string $opt Comma-separated list of index options.
 769         * @return string Option list
 770         */
 771         function addIndexOpt( $opt ) {
 772                 $this->opts[] = $opt;
 773
 774                 // Return the options list
 775                 return $this->opts;
 776         }
 777
 778         /**
 779         * Generates the SQL that will create the index in the database
 780         *
 781         * @param object $xmls adoSchema object
 782         * @return array Array containing index creation SQL
 783         */
 784         function create( &$xmls ) {
 785                 if( $this->drop ) {
 786                         return NULL;
 787                 }
 788
 789                 // eliminate any columns that aren't in the table
 790                 foreach( $this->columns as $id => $col ) {
 791                         if( !isset( $this->parent->fields[$id] ) ) {
 792                                 unset( $this->columns[$id] );
 793                         }
 794                 }
 795
 796                 return $xmls->dict->CreateIndexSQL( $this->name, $this->parent->name, $this->columns, $this->opts );
 797         }
 798
 799         /**
 800         * Marks an index for destruction
 801         */
 802         function drop() {
 803                 $this->drop = TRUE;
 804         }
 805 }
 806
 807 /**
 808 * Creates a data object in ADOdb's datadict format
 809 *
 810 * This class stores information about table data, and is called
 811 * when we need to load field data into a table.
 812 *
 813 * @package axmls
 814 * @access private
 815 */
 816 class dbData extends dbObject {
 817
 818         var $data = array();
 819
 820         var $row;
 821
 822         /**
 823         * Initializes the new dbData object.
 824         *
 825         * @param object $parent Parent object
 826         * @param array $attributes Attributes
 827         *
 828         * @internal
 829         */
 830         function dbData( &$parent, $attributes = NULL ) {
 831                 $this->parent =& $parent;
 832         }
 833
 834         /**
 835         * XML Callback to process start elements
 836         *
 837         * Processes XML opening tags.
 838         * Elements currently processed are: ROW and F (field).
 839         *
 840         * @access private
 841         */
 842         function _tag_open( &$parser, $tag, $attributes ) {
 843                 $this->currentElement = strtoupper( $tag );
 844
 845                 switch( $this->currentElement ) {
 846                         case 'ROW':
 847                                 $this->row = count( $this->data );
 848                                 $this->data[$this->row] = array();
 849                                 break;
 850                         case 'F':
 851                                 $this->addField($attributes);
 852                         default:
 853                                 // print_r( array( $tag, $attributes ) );
 854                 }
 855         }
 856
 857         /**
 858         * XML Callback to process CDATA elements
 859         *
 860         * Processes XML cdata.
 861         *
 862         * @access private
 863         */
 864         function _tag_cdata( &$parser, $cdata ) {
 865                 switch( $this->currentElement ) {
 866                         // Index field name
 867                         case 'F':
 868                                 $this->addData( $cdata );
 869                                 break;
 870                         default:
 871
 872                 }
 873         }
 874
 875         /**
 876         * XML Callback to process end elements
 877         *
 878         * @access private
 879         */
 880         function _tag_close( &$parser, $tag ) {
 881                 $this->currentElement = '';
 882
 883                 switch( strtoupper( $tag ) ) {
 884                         case 'DATA':
 885                                 xml_set_object( $parser, $this->parent );
 886                                 break;
 887                 }
 888         }
 889
 890         /**
 891         * Adds a field to the insert
 892         *
 893         * @param string $name Field name
 894         * @return string Field list
 895         */
 896         function addField( $attributes ) {
 897                 // check we're in a valid row
 898                 if( !isset( $this->row ) || !isset( $this->data[$this->row] ) ) {
 899                         return;
 900                 }
 901
 902                 // Set the field index so we know where we are
 903                 if( isset( $attributes['NAME'] ) ) {
 904                         $this->current_field = $this->FieldID( $attributes['NAME'] );
 905                 } else {
 906                         $this->current_field = count( $this->data[$this->row] );
 907                 }
 908
 909                 // initialise data
 910                 if( !isset( $this->data[$this->row][$this->current_field] ) ) {
 911                         $this->data[$this->row][$this->current_field] = '';
 912                 }
 913         }
 914
 915         /**
 916         * Adds options to the index
 917         *
 918         * @param string $opt Comma-separated list of index options.
 919         * @return string Option list
 920         */
 921         function addData( $cdata ) {
 922                 // check we're in a valid field
 923                 if ( isset( $this->data[$this->row][$this->current_field] ) ) {
 924                         // add data to field
 925                         $this->data[$this->row][$this->current_field] .= $cdata;
 926                 }
 927         }
 928
 929         /**
 930         * Generates the SQL that will add/update the data in the database
 931         *
 932         * @param object $xmls adoSchema object
 933         * @return array Array containing index creation SQL
 934         */
 935         function create( &$xmls ) {
 936                 $table = $xmls->dict->TableName($this->parent->name);
 937                 $table_field_count = count($this->parent->fields);
 938                 $tables = $xmls->db->MetaTables();
 939                 $sql = array();
 940
 941                 $ukeys = $xmls->db->MetaPrimaryKeys( $table );
 942                 if( !empty( $this->parent->indexes ) and !empty( $ukeys ) ) {
 943                         foreach( $this->parent->indexes as $indexObj ) {
 944                                 if( !in_array( $indexObj->name, $ukeys ) ) $ukeys[] = $indexObj->name;
 945                         }
 946                 }
 947
 948                 // eliminate any columns that aren't in the table
 949                 foreach( $this->data as $row ) {
 950                         $table_fields = $this->parent->fields;
 951                         $fields = array();
 952                         $rawfields = array(); // Need to keep some of the unprocessed data on hand.
 953
 954                         foreach( $row as $field_id => $field_data ) {
 955                                 if( !array_key_exists( $field_id, $table_fields ) ) {
 956                                         if( is_numeric( $field_id ) ) {
 957                                                 $field_id = reset( array_keys( $table_fields ) );
 958                                         } else {
 959                                                 continue;
 960                                         }
 961                                 }
 962
 963                                 $name = $table_fields[$field_id]['NAME'];
 964
 965                                 switch( $table_fields[$field_id]['TYPE'] ) {
 966                                         case 'I':
 967                                         case 'I1':
 968                                         case 'I2':
 969                                         case 'I4':
 970                                         case 'I8':
 971                                                 $fields[$name] = intval($field_data);
 972                                                 break;
 973                                         case 'C':
 974                                         case 'C2':
 975                                         case 'X':
 976                                         case 'X2':
 977                                         default:
 978                                                 $fields[$name] = $xmls->db->qstr( $field_data );
 979                                                 $rawfields[$name] = $field_data;
 980                                 }
 981
 982                                 unset($table_fields[$field_id]);
 983
 984                         }
 985
 986                         // check that at least 1 column is specified
 987                         if( empty( $fields ) ) {
 988                                 continue;
 989                         }
 990
 991                         // check that no required columns are missing
 992                         if( count( $fields ) < $table_field_count ) {
 993                                 foreach( $table_fields as $field ) {
 994                                         if( isset( $field['OPTS'] ) and ( in_array( 'NOTNULL', $field['OPTS'] ) || in_array( 'KEY', $field['OPTS'] ) ) && !in_array( 'AUTOINCREMENT', $field['OPTS'] ) ) {
 995                                                         continue(2);
 996                                                 }
 997                                 }
 998                         }
 999
1000                         // The rest of this method deals with updating existing data records.
1001
1002                         if( !in_array( $table, $tables ) or ( $mode = $xmls->existingData() ) == XMLS_MODE_INSERT ) {
1003                                 // Table doesn't yet exist, so it's safe to insert.
1004                                 logMsg( "$table doesn't exist, inserting or mode is INSERT" );
1005                         $sql[] = 'INSERT INTO '. $table .' ('. implode( ',', array_keys( $fields ) ) .') VALUES ('. implode( ',', $fields ) .')';
1006                                 continue;
1007                 }
1008
1009                         // Prepare to test for potential violations. Get primary keys and unique indexes
1010                         $mfields = array_merge( $fields, $rawfields );
1011                         $keyFields = array_intersect( $ukeys, array_keys( $mfields ) );
1012
1013                         if( empty( $ukeys ) or count( $keyFields ) == 0 ) {
1014                                 // No unique keys in schema, so safe to insert
1015                                 logMsg( "Either schema or data has no unique keys, so safe to insert" );
1016                                 $sql[] = 'INSERT INTO '. $table .' ('. implode( ',', array_keys( $fields ) ) .') VALUES ('. implode( ',', $fields ) .')';
1017                                 continue;
1018                         }
1019
1020                         // Select record containing matching unique keys.
1021                         $where = '';
1022                         foreach( $ukeys as $key ) {
1023                                 if( isset( $mfields[$key] ) and $mfields[$key] ) {
1024                                         if( $where ) $where .= ' AND ';
1025                                         $where .= $key . ' = ' . $xmls->db->qstr( $mfields[$key] );
1026                                 }
1027                         }
1028                         $records = $xmls->db->Execute( 'SELECT * FROM ' . $table . ' WHERE ' . $where );
1029                         switch( $records->RecordCount() ) {
1030                                 case 0:
1031                                         // No matching record, so safe to insert.
1032                                         logMsg( "No matching records. Inserting new row with unique data" );
1033                                         $sql[] = $xmls->db->GetInsertSQL( $records, $mfields );
1034                                         break;
1035                                 case 1:
1036                                         // Exactly one matching record, so we can update if the mode permits.
1037                                         logMsg( "One matching record..." );
1038                                         if( $mode == XMLS_MODE_UPDATE ) {
1039                                                 logMsg( "...Updating existing row from unique data" );
1040                                                 $sql[] = $xmls->db->GetUpdateSQL( $records, $mfields );
1041                                         }
1042                                         break;
1043                                 default:
1044                                         // More than one matching record; the result is ambiguous, so we must ignore the row.
1045                                         logMsg( "More than one matching record. Ignoring row." );
1046                         }
1047                 }
1048                 return $sql;
1049         }
1050 }
1051
1052 /**
1053 * Creates the SQL to execute a list of provided SQL queries
1054 *
1055 * @package axmls
1056 * @access private
1057 */
1058 class dbQuerySet extends dbObject {
1059
1060         /**
1061         * @var array    List of SQL queries
1062         */
1063         var $queries = array();
1064
1065         /**
1066         * @var string   String used to build of a query line by line
1067         */
1068         var $query;
1069
1070         /**
1071         * @var string   Query prefix key
1072         */
1073         var $prefixKey = '';
1074
1075         /**
1076         * @var boolean  Auto prefix enable (TRUE)
1077         */
1078         var $prefixMethod = 'AUTO';
1079
1080         /**
1081         * Initializes the query set.
1082         *
1083         * @param object $parent Parent object
1084         * @param array $attributes Attributes
1085         */
1086         function dbQuerySet( &$parent, $attributes = NULL ) {
1087                 $this->parent =& $parent;
1088
1089                 // Overrides the manual prefix key
1090                 if( isset( $attributes['KEY'] ) ) {
1091                         $this->prefixKey = $attributes['KEY'];
1092                 }
1093
1094                 $prefixMethod = isset( $attributes['PREFIXMETHOD'] ) ? strtoupper( trim( $attributes['PREFIXMETHOD'] ) ) : '';
1095
1096                 // Enables or disables automatic prefix prepending
1097                 switch( $prefixMethod ) {
1098                         case 'AUTO':
1099                                 $this->prefixMethod = 'AUTO';
1100                                 break;
1101                         case 'MANUAL':
1102                                 $this->prefixMethod = 'MANUAL';
1103                                 break;
1104                         case 'NONE':
1105                                 $this->prefixMethod = 'NONE';
1106                                 break;
1107                 }
1108         }
1109
1110         /**
1111         * XML Callback to process start elements. Elements currently
1112         * processed are: QUERY.
1113         *
1114         * @access private
1115         */
1116         function _tag_open( &$parser, $tag, $attributes ) {
1117                 $this->currentElement = strtoupper( $tag );
1118
1119                 switch( $this->currentElement ) {
1120                         case 'QUERY':
1121                                 // Create a new query in a SQL queryset.
1122                                 // Ignore this query set if a platform is specified and it's different than the
1123                                 // current connection platform.
1124                                 if( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) ) {
1125                                         $this->newQuery();
1126                                 } else {
1127                                         $this->discardQuery();
1128                                 }
1129                                 break;
1130                         default:
1131                                 // print_r( array( $tag, $attributes ) );
1132                 }
1133         }
1134
1135         /**
1136         * XML Callback to process CDATA elements
1137         */
1138         function _tag_cdata( &$parser, $cdata ) {
1139                 switch( $this->currentElement ) {
1140                         // Line of queryset SQL data
1141                         case 'QUERY':
1142                                 $this->buildQuery( $cdata );
1143                                 break;
1144                         default:
1145
1146                 }
1147         }
1148
1149         /**
1150         * XML Callback to process end elements
1151         *
1152         * @access private
1153         */
1154         function _tag_close( &$parser, $tag ) {
1155                 $this->currentElement = '';
1156
1157                 switch( strtoupper( $tag ) ) {
1158                         case 'QUERY':
1159                                 // Add the finished query to the open query set.
1160                                 $this->addQuery();
1161                                 break;
1162                         case 'SQL':
1163                                 $this->parent->addSQL( $this->create( $this->parent ) );
1164                                 xml_set_object( $parser, $this->parent );
1165                                 $this->destroy();
1166                                 break;
1167                         default:
1168
1169                 }
1170         }
1171
1172         /**
1173         * Re-initializes the query.
1174         *
1175         * @return boolean TRUE
1176         */
1177         function newQuery() {
1178                 $this->query = '';
1179
1180                 return TRUE;
1181         }
1182
1183         /**
1184         * Discards the existing query.
1185         *
1186         * @return boolean TRUE
1187         */
1188         function discardQuery() {
1189                 unset( $this->query );
1190
1191                 return TRUE;
1192         }
1193
1194         /**
1195         * Appends a line to a query that is being built line by line
1196         *
1197         * @param string $data Line of SQL data or NULL to initialize a new query
1198         * @return string SQL query string.
1199         */
1200         function buildQuery( $sql = NULL ) {
1201                 if( !isset( $this->query ) OR empty( $sql ) ) {
1202                         return FALSE;
1203                 }
1204
1205                 $this->query .= $sql;
1206
1207                 return $this->query;
1208         }
1209
1210         /**
1211         * Adds a completed query to the query list
1212         *
1213         * @return string        SQL of added query
1214         */
1215         function addQuery() {
1216                 if( !isset( $this->query ) ) {
1217                         return FALSE;
1218                 }
1219
1220                 $this->queries[] = $return = trim($this->query);
1221
1222                 unset( $this->query );
1223
1224                 return $return;
1225         }
1226
1227         /**
1228         * Creates and returns the current query set
1229         *
1230         * @param object $xmls adoSchema object
1231         * @return array Query set
1232         */
1233         function create( &$xmls ) {
1234                 foreach( $this->queries as $id => $query ) {
1235                         switch( $this->prefixMethod ) {
1236                                 case 'AUTO':
1237                                         // Enable auto prefix replacement
1238
1239                                         // Process object prefix.
1240                                         // Evaluate SQL statements to prepend prefix to objects
1241                                         $query = $this->prefixQuery( '/^\s*((?is)INSERT\s+(INTO\s+)?)((\w+\s*,?\s*)+)(\s.*$)/', $query, $xmls->objectPrefix );
1242                                         $query = $this->prefixQuery( '/^\s*((?is)UPDATE\s+(FROM\s+)?)((\w+\s*,?\s*)+)(\s.*$)/', $query, $xmls->objectPrefix );
1243                                         $query = $this->prefixQuery( '/^\s*((?is)DELETE\s+(FROM\s+)?)((\w+\s*,?\s*)+)(\s.*$)/', $query, $xmls->objectPrefix );
1244
1245                                         // SELECT statements aren't working yet
1246                                         #$data = preg_replace( '/(?ias)(^\s*SELECT\s+.*\s+FROM)\s+(\W\s*,?\s*)+((?i)\s+WHERE.*$)/', "\1 $prefix\2 \3", $data );
1247
1248                                 case 'MANUAL':
1249                                         // If prefixKey is set and has a value then we use it to override the default constant XMLS_PREFIX.
1250                                         // If prefixKey is not set, we use the default constant XMLS_PREFIX
1251                                         if( isset( $this->prefixKey ) AND( $this->prefixKey !== '' ) ) {
1252                                                 // Enable prefix override
1253                                                 $query = str_replace( $this->prefixKey, $xmls->objectPrefix, $query );
1254                                         } else {
1255                                                 // Use default replacement
1256                                                 $query = str_replace( XMLS_PREFIX , $xmls->objectPrefix, $query );
1257                                         }
1258                         }
1259
1260                         $this->queries[$id] = trim( $query );
1261                 }
1262
1263                 // Return the query set array
1264                 return $this->queries;
1265         }
1266
1267         /**
1268         * Rebuilds the query with the prefix attached to any objects
1269         *
1270         * @param string $regex Regex used to add prefix
1271         * @param string $query SQL query string
1272         * @param string $prefix Prefix to be appended to tables, indices, etc.
1273         * @return string Prefixed SQL query string.
1274         */
1275         function prefixQuery( $regex, $query, $prefix = NULL ) {
1276                 if( !isset( $prefix ) ) {
1277                         return $query;
1278                 }
1279
1280                 if( preg_match( $regex, $query, $match ) ) {
1281                         $preamble = $match[1];
1282                         $postamble = $match[5];
1283                         $objectList = explode( ',', $match[3] );
1284                         // $prefix = $prefix . '_';
1285
1286                         $prefixedList = '';
1287
1288                         foreach( $objectList as $object ) {
1289                                 if( $prefixedList !== '' ) {
1290                                         $prefixedList .= ', ';
1291                                 }
1292
1293                                 $prefixedList .= $prefix . trim( $object );
1294                         }
1295
1296                         $query = $preamble . ' ' . $prefixedList . ' ' . $postamble;
1297                 }
1298
1299                 return $query;
1300         }
1301 }
1302
1303 /**
1304 * Loads and parses an XML file, creating an array of "ready-to-run" SQL statements
1305 *
1306 * This class is used to load and parse the XML file, to create an array of SQL statements
1307 * that can be used to build a database, and to build the database using the SQL array.
1308 *
1309 * @tutorial getting_started.pkg
1310 *
1311 * @author Richard Tango-Lowy & Dan Cech
1312 * @version $Revision$
1313 *
1314 * @package axmls
1315 */
1316 class adoSchema {
1317
1318         /**
1319         * @var array    Array containing SQL queries to generate all objects
1320         * @access private
1321         */
1322         var $sqlArray;
1323
1324         /**
1325         * @var object   ADOdb connection object
1326         * @access private
1327         */
1328         var $db;
1329
1330         /**
1331         * @var object   ADOdb Data Dictionary
1332         * @access private
1333         */
1334         var $dict;
1335
1336         /**
1337         * @var string Current XML element
1338         * @access private
1339         */
1340         var $currentElement = '';
1341
1342         /**
1343         * @var string If set (to 'ALTER' or 'REPLACE'), upgrade an existing database
1344         * @access private
1345         */
1346         var $upgrade = '';
1347
1348         /**
1349         * @var string Optional object prefix
1350         * @access private
1351         */
1352         var $objectPrefix = '';
1353
1354         /**
1355         * @var long     Original Magic Quotes Runtime value
1356         * @access private
1357         */
1358         var $mgq;
1359
1360         /**
1361         * @var long     System debug
1362         * @access private
1363         */
1364         var $debug;
1365
1366         /**
1367         * @var string Regular expression to find schema version
1368         * @access private
1369         */
1370         var $versionRegex = '/<schema.*?( version="([^"]*)")?.*?>/';
1371
1372         /**
1373         * @var string Current schema version
1374         * @access private
1375         */
1376         var $schemaVersion;
1377
1378         /**
1379         * @var int      Success of last Schema execution
1380         */
1381         var $success;
1382
1383         /**
1384         * @var bool     Execute SQL inline as it is generated
1385         */
1386         var $executeInline;
1387
1388         /**
1389         * @var bool     Continue SQL execution if errors occur
1390         */
1391         var $continueOnError;
1392
1393         /**
1394         * @var int      How to handle existing data rows (insert, update, or ignore)
1395         */
1396         var $existingData;
1397
1398         /**
1399         * Creates an adoSchema object
1400         *
1401         * Creating an adoSchema object is the first step in processing an XML schema.
1402         * The only parameter is an ADOdb database connection object, which must already
1403         * have been created.
1404         *
1405         * @param object $db ADOdb database connection object.
1406         */
1407         function adoSchema( &$db ) {
1408                 // Initialize the environment
1409                 $this->mgq = get_magic_quotes_runtime();
1410                 set_magic_quotes_runtime(0);
1411
1412                 $this->db =& $db;
1413                 $this->debug = $this->db->debug;
1414                 $this->dict = NewDataDictionary( $this->db );
1415                 $this->sqlArray = array();
1416                 $this->schemaVersion = XMLS_SCHEMA_VERSION;
1417                 $this->executeInline( XMLS_EXECUTE_INLINE );
1418                 $this->continueOnError( XMLS_CONTINUE_ON_ERROR );
1419                 $this->existingData( XMLS_EXISTING_DATA );
1420                 $this->setUpgradeMethod();
1421         }
1422
1423         /**
1424         * Sets the method to be used for upgrading an existing database
1425         *
1426         * Use this method to specify how existing database objects should be upgraded.
1427         * The method option can be set to ALTER, REPLACE, BEST, or NONE. ALTER attempts to
1428         * alter each database object directly, REPLACE attempts to rebuild each object
1429         * from scratch, BEST attempts to determine the best upgrade method for each
1430         * object, and NONE disables upgrading.
1431         *
1432         * This method is not yet used by AXMLS, but exists for backward compatibility.
1433         * The ALTER method is automatically assumed when the adoSchema object is
1434         * instantiated; other upgrade methods are not currently supported.
1435         *
1436         * @param string $method Upgrade method (ALTER|REPLACE|BEST|NONE)
1437         * @returns string Upgrade method used
1438         */
1439         function SetUpgradeMethod( $method = '' ) {
1440                 if( !is_string( $method ) ) {
1441                         return FALSE;
1442                 }
1443
1444                 $method = strtoupper( $method );
1445
1446                 // Handle the upgrade methods
1447                 switch( $method ) {
1448                         case 'ALTER':
1449                                 $this->upgrade = $method;
1450                                 break;
1451                         case 'REPLACE':
1452                                 $this->upgrade = $method;
1453                                 break;
1454                         case 'BEST':
1455                                 $this->upgrade = 'ALTER';
1456                                 break;
1457                         case 'NONE':
1458                                 $this->upgrade = 'NONE';
1459                                 break;
1460                         default:
1461                                 // Use default if no legitimate method is passed.
1462                                 $this->upgrade = XMLS_DEFAULT_UPGRADE_METHOD;
1463                 }
1464
1465                 return $this->upgrade;
1466         }
1467
1468         /**
1469         * Specifies how to handle existing data row when there is a unique key conflict.
1470         *
1471         * The existingData setting specifies how the parser should handle existing rows
1472         * when a unique key violation occurs during the insert. This can happen when inserting
1473         * data into an existing table with one or more primary keys or unique indexes.
1474         * The existingData method takes one of three options: XMLS_MODE_INSERT attempts
1475         * to always insert the data as a new row. In the event of a unique key violation,
1476         * the database will generate an error.  XMLS_MODE_UPDATE attempts to update the
1477         * any existing rows with the new data based upon primary or unique key fields in
1478         * the schema. If the data row in the schema specifies no unique fields, the row
1479         * data will be inserted as a new row. XMLS_MODE_IGNORE specifies that any data rows
1480         * that would result in a unique key violation be ignored; no inserts or updates will
1481         * take place. For backward compatibility, the default setting is XMLS_MODE_INSERT,
1482         * but XMLS_MODE_UPDATE will generally be the most appropriate setting.
1483         *
1484         * @param int $mode XMLS_MODE_INSERT, XMLS_MODE_UPDATE, or XMLS_MODE_IGNORE
1485         * @return int current mode
1486         */
1487         function ExistingData( $mode = NULL ) {
1488                 if( is_int( $mode ) ) {
1489                         switch( $mode ) {
1490                                 case XMLS_MODE_UPDATE:
1491                                         $mode = XMLS_MODE_UPDATE;
1492                                         break;
1493                                 case XMLS_MODE_IGNORE:
1494                                         $mode = XMLS_MODE_IGNORE;
1495                                         break;
1496                                 case XMLS_MODE_INSERT:
1497                                         $mode = XMLS_MODE_INSERT;
1498                                         break;
1499                                 default:
1500                                         $mode = XMLS_EXISITNG_DATA;
1501                                         break;
1502                         }
1503                         $this->existingData = $mode;
1504                 }
1505
1506                 return $this->existingData;
1507         }
1508
1509         /**
1510         * Enables/disables inline SQL execution.
1511         *
1512         * Call this method to enable or disable inline execution of the schema. If the mode is set to TRUE (inline execution),
1513         * AXMLS applies the SQL to the database immediately as each schema entity is parsed. If the mode
1514         * is set to FALSE (post execution), AXMLS parses the entire schema and you will need to call adoSchema::ExecuteSchema()
1515         * to apply the schema to the database.
1516         *
1517         * @param bool $mode execute
1518         * @return bool current execution mode
1519         *
1520         * @see ParseSchema(), ExecuteSchema()
1521         */
1522         function ExecuteInline( $mode = NULL ) {
1523                 if( is_bool( $mode ) ) {
1524                         $this->executeInline = $mode;
1525                 }
1526
1527                 return $this->executeInline;
1528         }
1529
1530         /**
1531         * Enables/disables SQL continue on error.
1532         *
1533         * Call this method to enable or disable continuation of SQL execution if an error occurs.
1534         * If the mode is set to TRUE (continue), AXMLS will continue to apply SQL to the database, even if an error occurs.
1535         * If the mode is set to FALSE (halt), AXMLS will halt execution of generated sql if an error occurs, though parsing
1536         * of the schema will continue.
1537         *
1538         * @param bool $mode execute
1539         * @return bool current continueOnError mode
1540         *
1541         * @see addSQL(), ExecuteSchema()
1542         */
1543         function ContinueOnError( $mode = NULL ) {
1544                 if( is_bool( $mode ) ) {
1545                         $this->continueOnError = $mode;
1546                 }
1547
1548                 return $this->continueOnError;
1549         }
1550
1551         /**
1552         * Loads an XML schema from a file and converts it to SQL.
1553         *
1554         * Call this method to load the specified schema (see the DTD for the proper format) from
1555         * the filesystem and generate the SQL necessary to create the database
1556         * described. This method automatically converts the schema to the latest
1557         * axmls schema version.
1558         * @see ParseSchemaString()
1559         *
1560         * @param string $file Name of XML schema file.
1561         * @param bool $returnSchema Return schema rather than parsing.
1562         * @return array Array of SQL queries, ready to execute
1563         */
1564         function ParseSchema( $filename, $returnSchema = FALSE ) {
1565                 return $this->ParseSchemaString( $this->ConvertSchemaFile( $filename ), $returnSchema );
1566         }
1567
1568         /**
1569         * Loads an XML schema from a file and converts it to SQL.
1570         *
1571         * Call this method to load the specified schema directly from a file (see
1572         * the DTD for the proper format) and generate the SQL necessary to create
1573         * the database described by the schema. Use this method when you are dealing
1574         * with large schema files. Otherwise, ParseSchema() is faster.
1575         * This method does not automatically convert the schema to the latest axmls
1576         * schema version. You must convert the schema manually using either the
1577         * ConvertSchemaFile() or ConvertSchemaString() method.
1578         * @see ParseSchema()
1579         * @see ConvertSchemaFile()
1580         * @see ConvertSchemaString()
1581         *
1582         * @param string $file Name of XML schema file.
1583         * @param bool $returnSchema Return schema rather than parsing.
1584         * @return array Array of SQL queries, ready to execute.
1585         *
1586         * @deprecated Replaced by adoSchema::ParseSchema() and adoSchema::ParseSchemaString()
1587         * @see ParseSchema(), ParseSchemaString()
1588         */
1589         function ParseSchemaFile( $filename, $returnSchema = FALSE ) {
1590                 // Open the file
1591                 if( !($fp = fopen( $filename, 'r' )) ) {
1592                         logMsg( 'Unable to open file' );
1593                         return FALSE;
1594                 }
1595
1596                 // do version detection here
1597                 if( $this->SchemaFileVersion( $filename ) != $this->schemaVersion ) {
1598                         logMsg( 'Invalid Schema Version' );
1599                         return FALSE;
1600                 }
1601
1602                 if( $returnSchema ) {
1603                         $xmlstring = '';
1604                         while( $data = fread( $fp, 4096 ) ) {
1605                                 $xmlstring .= $data . "\n";
1606                         }
1607                         return $xmlstring;
1608                 }
1609
1610                 $this->success = 2;
1611
1612                 $xmlParser = $this->create_parser();
1613
1614                 // Process the file
1615                 while( $data = fread( $fp, 4096 ) ) {
1616                         if( !xml_parse( $xmlParser, $data, feof( $fp ) ) ) {
1617                                 die( sprintf(
1618                                         "XML error: %s at line %d",
1619                                         xml_error_string( xml_get_error_code( $xmlParser) ),
1620                                         xml_get_current_line_number( $xmlParser)
1621                                 ) );
1622                         }
1623                 }
1624
1625                 xml_parser_free( $xmlParser );
1626
1627                 return $this->sqlArray;
1628         }
1629
1630         /**
1631         * Converts an XML schema string to SQL.
1632         *
1633         * Call this method to parse a string containing an XML schema (see the DTD for the proper format)
1634         * and generate the SQL necessary to create the database described by the schema.
1635         * @see ParseSchema()
1636         *
1637         * @param string $xmlstring XML schema string.
1638         * @param bool $returnSchema Return schema rather than parsing.
1639         * @return array Array of SQL queries, ready to execute.
1640         */
1641         function ParseSchemaString( $xmlstring, $returnSchema = FALSE ) {
1642                 if( !is_string( $xmlstring ) OR empty( $xmlstring ) ) {
1643                         logMsg( 'Empty or Invalid Schema' );
1644                         return FALSE;
1645                 }
1646
1647                 // do version detection here
1648                 if( $this->SchemaStringVersion( $xmlstring ) != $this->schemaVersion ) {
1649                         logMsg( 'Invalid Schema Version' );
1650                         return FALSE;
1651                 }
1652
1653                 if( $returnSchema ) {
1654                         return $xmlstring;
1655                 }
1656
1657                 $this->success = 2;
1658
1659                 $xmlParser = $this->create_parser();
1660
1661                 if( !xml_parse( $xmlParser, $xmlstring, TRUE ) ) {
1662                         die( sprintf(
1663                                 "XML error: %s at line %d",
1664                                 xml_error_string( xml_get_error_code( $xmlParser) ),
1665                                 xml_get_current_line_number( $xmlParser)
1666                         ) );
1667                 }
1668
1669                 xml_parser_free( $xmlParser );
1670
1671                 return $this->sqlArray;
1672         }
1673
1674         /**
1675         * Loads an XML schema from a file and converts it to uninstallation SQL.
1676         *
1677         * Call this method to load the specified schema (see the DTD for the proper format) from
1678         * the filesystem and generate the SQL necessary to remove the database described.
1679         * @see RemoveSchemaString()
1680         *
1681         * @param string $file Name of XML schema file.
1682         * @param bool $returnSchema Return schema rather than parsing.
1683         * @return array Array of SQL queries, ready to execute
1684         */
1685         function RemoveSchema( $filename, $returnSchema = FALSE ) {
1686                 return $this->RemoveSchemaString( $this->ConvertSchemaFile( $filename ), $returnSchema );
1687         }
1688
1689         /**
1690         * Converts an XML schema string to uninstallation SQL.
1691         *
1692         * Call this method to parse a string containing an XML schema (see the DTD for the proper format)
1693         * and generate the SQL necessary to uninstall the database described by the schema.
1694         * @see RemoveSchema()
1695         *
1696         * @param string $schema XML schema string.
1697         * @param bool $returnSchema Return schema rather than parsing.
1698         * @return array Array of SQL queries, ready to execute.
1699         */
1700         function RemoveSchemaString( $schema, $returnSchema = FALSE ) {
1701
1702                 // grab current version
1703                 if( !( $version = $this->SchemaStringVersion( $schema ) ) ) {
1704                         return FALSE;
1705                 }
1706
1707                 return $this->ParseSchemaString( $this->TransformSchema( $schema, 'remove-' . $version), $returnSchema );
1708         }
1709
1710         /**
1711         * Applies the current XML schema to the database (post execution).
1712         *
1713         * Call this method to apply the current schema (generally created by calling
1714         * ParseSchema() or ParseSchemaString() ) to the database (creating the tables, indexes,
1715         * and executing other SQL specified in the schema) after parsing.
1716         * @see ParseSchema(), ParseSchemaString(), ExecuteInline()
1717         *
1718         * @param array $sqlArray Array of SQL statements that will be applied rather than
1719         *               the current schema.
1720         * @param boolean $continueOnErr Continue to apply the schema even if an error occurs.
1721         * @returns integer 0 if failure, 1 if errors, 2 if successful.
1722         */
1723         function ExecuteSchema( $sqlArray = NULL, $continueOnErr =  NULL ) {
1724                 if( !is_bool( $continueOnErr ) ) {
1725                         $continueOnErr = $this->ContinueOnError();
1726                 }
1727
1728                 if( !isset( $sqlArray ) ) {
1729                         $sqlArray = $this->sqlArray;
1730                 }
1731
1732                 if( !is_array( $sqlArray ) ) {
1733                         $this->success = 0;
1734                 } else {
1735                         $this->success = $this->dict->ExecuteSQLArray( $sqlArray, $continueOnErr );
1736                 }
1737
1738                 return $this->success;
1739         }
1740
1741         /**
1742         * Returns the current SQL array.
1743         *
1744         * Call this method to fetch the array of SQL queries resulting from
1745         * ParseSchema() or ParseSchemaString().
1746         *
1747         * @param string $format Format: HTML, TEXT, or NONE (PHP array)
1748         * @return array Array of SQL statements or FALSE if an error occurs
1749         */
1750         function PrintSQL( $format = 'NONE' ) {
1751                 $sqlArray = null;
1752                 return $this->getSQL( $format, $sqlArray );
1753         }
1754
1755         /**
1756         * Saves the current SQL array to the local filesystem as a list of SQL queries.
1757         *
1758         * Call this method to save the array of SQL queries (generally resulting from a
1759         * parsed XML schema) to the filesystem.
1760         *
1761         * @param string $filename Path and name where the file should be saved.
1762         * @return boolean TRUE if save is successful, else FALSE.
1763         */
1764         function SaveSQL( $filename = './schema.sql' ) {
1765
1766                 if( !isset( $sqlArray ) ) {
1767                         $sqlArray = $this->sqlArray;
1768                 }
1769                 if( !isset( $sqlArray ) ) {
1770                         return FALSE;
1771                 }
1772
1773                 $fp = fopen( $filename, "w" );
1774
1775                 foreach( $sqlArray as $key => $query ) {
1776                         fwrite( $fp, $query . ";\n" );
1777                 }
1778                 fclose( $fp );
1779         }
1780
1781         /**
1782         * Create an xml parser
1783         *
1784         * @return object PHP XML parser object
1785         *
1786         * @access private
1787         */
1788         function &create_parser() {
1789                 // Create the parser
1790                 $xmlParser = xml_parser_create();
1791                 xml_set_object( $xmlParser, $this );
1792
1793                 // Initialize the XML callback functions
1794                 xml_set_element_handler( $xmlParser, '_tag_open', '_tag_close' );
1795                 xml_set_character_data_handler( $xmlParser, '_tag_cdata' );
1796
1797                 return $xmlParser;
1798         }
1799
1800         /**
1801         * XML Callback to process start elements
1802         *
1803         * @access private
1804         */
1805         function _tag_open( &$parser, $tag, $attributes ) {
1806                 switch( strtoupper( $tag ) ) {
1807                         case 'TABLE':
1808                                 if( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) ) {
1809                                 $this->obj = new dbTable( $this, $attributes );
1810                                 xml_set_object( $parser, $this->obj );
1811                                 }
1812                                 break;
1813                         case 'SQL':
1814                                 if( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) ) {
1815                                         $this->obj = new dbQuerySet( $this, $attributes );
1816                                         xml_set_object( $parser, $this->obj );
1817                                 }
1818                                 break;
1819                         default:
1820                                 // print_r( array( $tag, $attributes ) );
1821                 }
1822
1823         }
1824
1825         /**
1826         * XML Callback to process CDATA elements
1827         *
1828         * @access private
1829         */
1830         function _tag_cdata( &$parser, $cdata ) {
1831         }
1832
1833         /**
1834         * XML Callback to process end elements
1835         *
1836         * @access private
1837         * @internal
1838         */
1839         function _tag_close( &$parser, $tag ) {
1840
1841         }
1842
1843         /**
1844         * Converts an XML schema string to the specified DTD version.
1845         *
1846         * Call this method to convert a string containing an XML schema to a different AXMLS
1847         * DTD version. For instance, to convert a schema created for an pre-1.0 version for
1848         * AXMLS (DTD version 0.1) to a newer version of the DTD (e.g. 0.2). If no DTD version
1849         * parameter is specified, the schema will be converted to the current DTD version.
1850         * If the newFile parameter is provided, the converted schema will be written to the specified
1851         * file.
1852         * @see ConvertSchemaFile()
1853         *
1854         * @param string $schema String containing XML schema that will be converted.
1855         * @param string $newVersion DTD version to convert to.
1856         * @param string $newFile File name of (converted) output file.
1857         * @return string Converted XML schema or FALSE if an error occurs.
1858         */
1859         function ConvertSchemaString( $schema, $newVersion = NULL, $newFile = NULL ) {
1860
1861                 // grab current version
1862                 if( !( $version = $this->SchemaStringVersion( $schema ) ) ) {
1863                         return FALSE;
1864                 }
1865
1866                 if( !isset ($newVersion) ) {
1867                         $newVersion = $this->schemaVersion;
1868                 }
1869
1870                 if( $version == $newVersion ) {
1871                         $result = $schema;
1872                 } else {
1873                         $result = $this->TransformSchema( $schema, 'convert-' . $version . '-' . $newVersion);
1874                 }
1875
1876                 if( is_string( $result ) AND is_string( $newFile ) AND ( $fp = fopen( $newFile, 'w' ) ) ) {
1877                         fwrite( $fp, $result );
1878                         fclose( $fp );
1879                 }
1880
1881                 return $result;
1882         }
1883
1884         /*
1885         // compat for pre-4.3 - jlim
1886         function _file_get_contents($path)
1887         {
1888                 if (function_exists('file_get_contents')) return file_get_contents($path);
1889                 return join('',file($path));
1890         }*/
1891
1892         /**
1893         * Converts an XML schema file to the specified DTD version.
1894         *
1895         * Call this method to convert the specified XML schema file to a different AXMLS
1896         * DTD version. For instance, to convert a schema created for an pre-1.0 version for
1897         * AXMLS (DTD version 0.1) to a newer version of the DTD (e.g. 0.2). If no DTD version
1898         * parameter is specified, the schema will be converted to the current DTD version.
1899         * If the newFile parameter is provided, the converted schema will be written to the specified
1900         * file.
1901         * @see ConvertSchemaString()
1902         *
1903         * @param string $filename Name of XML schema file that will be converted.
1904         * @param string $newVersion DTD version to convert to.
1905         * @param string $newFile File name of (converted) output file.
1906         * @return string Converted XML schema or FALSE if an error occurs.
1907         */
1908         function ConvertSchemaFile( $filename, $newVersion = NULL, $newFile = NULL ) {
1909
1910                 // grab current version
1911                 if( !( $version = $this->SchemaFileVersion( $filename ) ) ) {
1912                         return FALSE;
1913                 }
1914
1915                 if( !isset ($newVersion) ) {
1916                         $newVersion = $this->schemaVersion;
1917                 }
1918
1919                 if( $version == $newVersion ) {
1920                         $result = _file_get_contents( $filename );
1921
1922                         // remove unicode BOM if present
1923                         if( substr( $result, 0, 3 ) == sprintf( '%c%c%c', 239, 187, 191 ) ) {
1924                                 $result = substr( $result, 3 );
1925                         }
1926                 } else {
1927                         $result = $this->TransformSchema( $filename, 'convert-' . $version . '-' . $newVersion, 'file' );
1928                 }
1929
1930                 if( is_string( $result ) AND is_string( $newFile ) AND ( $fp = fopen( $newFile, 'w' ) ) ) {
1931                         fwrite( $fp, $result );
1932                         fclose( $fp );
1933                 }
1934
1935                 return $result;
1936         }
1937
1938         function TransformSchema( $schema, $xsl, $schematype='string' )
1939         {
1940                 // Fail if XSLT extension is not available
1941                 if( ! function_exists( 'xslt_create' ) ) {
1942                         return FALSE;
1943                 }
1944
1945                 $xsl_file = dirname( __FILE__ ) . '/xsl/' . $xsl . '.xsl';
1946
1947                 // look for xsl
1948                 if( !is_readable( $xsl_file ) ) {
1949                         return FALSE;
1950                 }
1951
1952                 switch( $schematype )
1953                 {
1954                         case 'file':
1955                                 if( !is_readable( $schema ) ) {
1956                                         return FALSE;
1957                                 }
1958
1959                                 $schema = _file_get_contents( $schema );
1960                                 break;
1961                         case 'string':
1962                         default:
1963                                 if( !is_string( $schema ) ) {
1964                                         return FALSE;
1965                                 }
1966                 }
1967
1968                 $arguments = array (
1969                         '/_xml' => $schema,
1970                         '/_xsl' => _file_get_contents( $xsl_file )
1971                 );
1972
1973                 // create an XSLT processor
1974                 $xh = xslt_create ();
1975
1976                 // set error handler
1977                 xslt_set_error_handler ($xh, array (&$this, 'xslt_error_handler'));
1978
1979                 // process the schema
1980                 $result = xslt_process ($xh, 'arg:/_xml', 'arg:/_xsl', NULL, $arguments);
1981
1982                 xslt_free ($xh);
1983
1984                 return $result;
1985         }
1986
1987         /**
1988         * Processes XSLT transformation errors
1989         *
1990         * @param object $parser XML parser object
1991         * @param integer $errno Error number
1992         * @param integer $level Error level
1993         * @param array $fields Error information fields
1994         *
1995         * @access private
1996         */
1997         function xslt_error_handler( $parser, $errno, $level, $fields ) {
1998                 if( is_array( $fields ) ) {
1999                         $msg = array(
2000                                 'Message Type' => ucfirst( $fields['msgtype'] ),
2001                                 'Message Code' => $fields['code'],
2002                                 'Message' => $fields['msg'],
2003                                 'Error Number' => $errno,
2004                                 'Level' => $level
2005                         );
2006
2007                         switch( $fields['URI'] ) {
2008                                 case 'arg:/_xml':
2009                                         $msg['Input'] = 'XML';
2010                                         break;
2011                                 case 'arg:/_xsl':
2012                                         $msg['Input'] = 'XSL';
2013                                         break;
2014                                 default:
2015                                         $msg['Input'] = $fields['URI'];
2016                         }
2017
2018                         $msg['Line'] = $fields['line'];
2019                 } else {
2020                         $msg = array(
2021                                 'Message Type' => 'Error',
2022                                 'Error Number' => $errno,
2023                                 'Level' => $level,
2024                                 'Fields' => var_export( $fields, TRUE )
2025                         );
2026                 }
2027
2028                 $error_details = $msg['Message Type'] . ' in XSLT Transformation' . "\n"
2029                                            . '<table>' . "\n";
2030
2031                 foreach( $msg as $label => $details ) {
2032                         $error_details .= '<tr><td><b>' . $label . ': </b></td><td>' . htmlentities( $details ) . '</td></tr>' . "\n";
2033                 }
2034
2035                 $error_details .= '</table>';
2036
2037                 trigger_error( $error_details, E_USER_ERROR );
2038         }
2039
2040         /**
2041         * Returns the AXMLS Schema Version of the requested XML schema file.
2042         *
2043         * Call this method to obtain the AXMLS DTD version of the requested XML schema file.
2044         * @see SchemaStringVersion()
2045         *
2046         * @param string $filename AXMLS schema file
2047         * @return string Schema version number or FALSE on error
2048         */
2049         function SchemaFileVersion( $filename ) {
2050                 // Open the file
2051                 if( !($fp = fopen( $filename, 'r' )) ) {
2052                         // die( 'Unable to open file' );
2053                         return FALSE;
2054                 }
2055
2056                 // Process the file
2057                 while( $data = fread( $fp, 4096 ) ) {
2058                         if( preg_match( $this->versionRegex, $data, $matches ) ) {
2059                                 return !empty( $matches[2] ) ? $matches[2] : XMLS_DEFAULT_SCHEMA_VERSION;
2060                         }
2061                 }
2062
2063                 return FALSE;
2064         }
2065
2066         /**
2067         * Returns the AXMLS Schema Version of the provided XML schema string.
2068         *
2069         * Call this method to obtain the AXMLS DTD version of the provided XML schema string.
2070         * @see SchemaFileVersion()
2071         *
2072         * @param string $xmlstring XML schema string
2073         * @return string Schema version number or FALSE on error
2074         */
2075         function SchemaStringVersion( $xmlstring ) {
2076                 if( !is_string( $xmlstring ) OR empty( $xmlstring ) ) {
2077                         return FALSE;
2078                 }
2079
2080                 if( preg_match( $this->versionRegex, $xmlstring, $matches ) ) {
2081                         return !empty( $matches[2] ) ? $matches[2] : XMLS_DEFAULT_SCHEMA_VERSION;
2082                 }
2083
2084                 return FALSE;
2085         }
2086
2087         /**
2088         * Extracts an XML schema from an existing database.
2089         *
2090         * Call this method to create an XML schema string from an existing database.
2091         * If the data parameter is set to TRUE, AXMLS will include the data from the database
2092         * in the schema.
2093         *
2094         * @param boolean $data Include data in schema dump
2095         * @indent string indentation to use
2096         * @prefix string extract only tables with given prefix
2097         * @stripprefix strip prefix string when storing in XML schema
2098         * @return string Generated XML schema
2099         */
2100         function ExtractSchema( $data = FALSE, $indent = '  ', $prefix = '' , $stripprefix=false) {
2101                 $old_mode = $this->db->SetFetchMode( ADODB_FETCH_NUM );
2102
2103                 $schema = '<?xml version="1.0"?>' . "\n"
2104                                 . '<schema version="' . $this->schemaVersion . '">' . "\n";
2105
2106                 if( is_array( $tables = $this->db->MetaTables( 'TABLES' , ($prefix) ? $prefix.'%' : '') ) ) {
2107                         foreach( $tables as $table ) {
2108                                 if ($stripprefix) $table = str_replace(str_replace('\\_', '_', $pfx ), '', $table);
2109                                 $schema .= $indent . '<table name="' . htmlentities( $table ) . '">' . "\n";
2110
2111                                 // grab details from database
2112                                 $rs = $this->db->Execute( 'SELECT * FROM ' . $table . ' WHERE -1' );
2113                                 $fields = $this->db->MetaColumns( $table );
2114                                 $indexes = $this->db->MetaIndexes( $table );
2115
2116                                 if( is_array( $fields ) ) {
2117                                         foreach( $fields as $details ) {
2118                                                 $extra = '';
2119                                                 $content = array();
2120
2121                                                 if( isset($details->max_length) && $details->max_length > 0 ) {
2122                                                         $extra .= ' size="' . $details->max_length . '"';
2123                                                 }
2124
2125                                                 if( isset($details->primary_key) && $details->primary_key ) {
2126                                                         $content[] = '<KEY/>';
2127                                                 } elseif( isset($details->not_null) && $details->not_null ) {
2128                                                         $content[] = '<NOTNULL/>';
2129                                                 }
2130
2131                                                 if( isset($details->has_default) && $details->has_default ) {
2132                                                         $content[] = '<DEFAULT value="' . htmlentities( $details->default_value ) . '"/>';
2133                                                 }
2134
2135                                                 if( isset($details->auto_increment) && $details->auto_increment ) {
2136                                                         $content[] = '<AUTOINCREMENT/>';
2137                                                 }
2138
2139                                                 if( isset($details->unsigned) && $details->unsigned ) {
2140                                                         $content[] = '<UNSIGNED/>';
2141                                                 }
2142
2143                                                 // this stops the creation of 'R' columns,
2144                                                 // AUTOINCREMENT is used to create auto columns
2145                                                 $details->primary_key = 0;
2146                                                 $type = $rs->MetaType( $details );
2147
2148                                                 $schema .= str_repeat( $indent, 2 ) . '<field name="' . htmlentities( $details->name ) . '" type="' . $type . '"' . $extra;
2149
2150                                                 if( !empty( $content ) ) {
2151                                                         $schema .= ">\n" . str_repeat( $indent, 3 )
2152                                                                          . implode( "\n" . str_repeat( $indent, 3 ), $content ) . "\n"
2153                                                                          . str_repeat( $indent, 2 ) . '</field>' . "\n";
2154                                                 } else {
2155                                                         $schema .= "/>\n";
2156                                                 }
2157                                         }
2158                                 }
2159
2160                                 if( is_array( $indexes ) ) {
2161                                         foreach( $indexes as $index => $details ) {
2162                                                 $schema .= str_repeat( $indent, 2 ) . '<index name="' . $index . '">' . "\n";
2163
2164                                                 if( $details['unique'] ) {
2165                                                         $schema .= str_repeat( $indent, 3 ) . '<UNIQUE/>' . "\n";
2166                                                 }
2167
2168                                                 foreach( $details['columns'] as $column ) {
2169                                                         $schema .= str_repeat( $indent, 3 ) . '<col>' . htmlentities( $column ) . '</col>' . "\n";
2170                                                 }
2171
2172                                                 $schema .= str_repeat( $indent, 2 ) . '</index>' . "\n";
2173                                         }
2174                                 }
2175
2176                                 if( $data ) {
2177                                         $rs = $this->db->Execute( 'SELECT * FROM ' . $table );
2178
2179                                         if( is_object( $rs ) && !$rs->EOF ) {
2180                                                 $schema .= str_repeat( $indent, 2 ) . "<data>\n";
2181
2182                                                 while( $row = $rs->FetchRow() ) {
2183                                                         foreach( $row as $key => $val ) {
2184                                                                 if ( $val != htmlentities( $val ) ) {
2185                                                                         $row[$key] = '<![CDATA[' . $val . ']]>';
2186                                                                 }
2187                                                         }
2188
2189                                                         $schema .= str_repeat( $indent, 3 ) . '<row><f>' . implode( '</f><f>', $row ) . "</f></row>\n";
2190                                                 }
2191
2192                                                 $schema .= str_repeat( $indent, 2 ) . "</data>\n";
2193                                         }
2194                                 }
2195
2196                                 $schema .= $indent . "</table>\n";
2197                         }
2198                 }
2199
2200                 $this->db->SetFetchMode( $old_mode );
2201
2202                 $schema .= '</schema>';
2203                 return $schema;
2204         }
2205
2206         /**
2207         * Sets a prefix for database objects
2208         *
2209         * Call this method to set a standard prefix that will be prepended to all database tables
2210         * and indices when the schema is parsed. Calling setPrefix with no arguments clears the prefix.
2211         *
2212         * @param string $prefix Prefix that will be prepended.
2213         * @param boolean $underscore If TRUE, automatically append an underscore character to the prefix.
2214         * @return boolean TRUE if successful, else FALSE
2215         */
2216         function SetPrefix( $prefix = '', $underscore = TRUE ) {
2217                 switch( TRUE ) {
2218                         // clear prefix
2219                         case empty( $prefix ):
2220                                 logMsg( 'Cleared prefix' );
2221                                 $this->objectPrefix = '';
2222                                 return TRUE;
2223                         // prefix too long
2224                         case strlen( $prefix ) > XMLS_PREFIX_MAXLEN:
2225                         // prefix contains invalid characters
2226                         case !preg_match( '/^[a-z][a-z0-9_]+$/i', $prefix ):
2227                                 logMsg( 'Invalid prefix: ' . $prefix );
2228                                 return FALSE;
2229                 }
2230
2231                 if( $underscore AND substr( $prefix, -1 ) != '_' ) {
2232                         $prefix .= '_';
2233                 }
2234
2235                 // prefix valid
2236                 logMsg( 'Set prefix: ' . $prefix );
2237                 $this->objectPrefix = $prefix;
2238                 return TRUE;
2239         }
2240
2241         /**
2242         * Returns an object name with the current prefix prepended.
2243         *
2244         * @param string $name Name
2245         * @return string        Prefixed name
2246         *
2247         * @access private
2248         */
2249         function prefix( $name = '' ) {
2250                 // if prefix is set
2251                 if( !empty( $this->objectPrefix ) ) {
2252                         // Prepend the object prefix to the table name
2253                         // prepend after quote if used
2254                         return preg_replace( '/^(`?)(.+)$/', '$1' . $this->objectPrefix . '$2', $name );
2255                 }
2256
2257                 // No prefix set. Use name provided.
2258                 return $name;
2259         }
2260
2261         /**
2262         * Checks if element references a specific platform
2263         *
2264         * @param string $platform Requested platform
2265         * @returns boolean TRUE if platform check succeeds
2266         *
2267         * @access private
2268         */
2269         function supportedPlatform( $platform = NULL ) {
2270                 if( !empty( $platform ) ) {
2271                         $regex = '/(^|\|)' . $this->db->databaseType . '(\||$)/i';
2272
2273                         if( preg_match( '/^- /', $platform ) ) {
2274                                 if (preg_match ( $regex, substr( $platform, 2 ) ) ) {
2275                                         logMsg( 'Platform ' . $platform . ' is NOT supported' );
2276                                         return FALSE;
2277                                 }
2278                 } else {
2279                                 if( !preg_match ( $regex, $platform ) ) {
2280                                         logMsg( 'Platform ' . $platform . ' is NOT supported' );
2281                         return FALSE;
2282                 }
2283         }
2284                 }
2285
2286                 logMsg( 'Platform ' . $platform . ' is supported' );
2287                 return TRUE;
2288         }
2289
2290         /**
2291         * Clears the array of generated SQL.
2292         *
2293         * @access private
2294         */
2295         function clearSQL() {
2296                 $this->sqlArray = array();
2297         }
2298
2299         /**
2300         * Adds SQL into the SQL array.
2301         *
2302         * @param mixed $sql SQL to Add
2303         * @return boolean TRUE if successful, else FALSE.
2304         *
2305         * @access private
2306         */
2307         function addSQL( $sql = NULL ) {
2308                 if( is_array( $sql ) ) {
2309                         foreach( $sql as $line ) {
2310                                 $this->addSQL( $line );
2311                         }
2312
2313                         return TRUE;
2314                 }
2315
2316                 if( is_string( $sql ) ) {
2317                         $this->sqlArray[] = $sql;
2318
2319                         // if executeInline is enabled, and either no errors have occurred or continueOnError is enabled, execute SQL.
2320                         if( $this->ExecuteInline() && ( $this->success == 2 || $this->ContinueOnError() ) ) {
2321                                 $saved = $this->db->debug;
2322                                 $this->db->debug = $this->debug;
2323                                 $ok = $this->db->Execute( $sql );
2324                                 $this->db->debug = $saved;
2325
2326                                 if( !$ok ) {
2327                                         if( $this->debug ) {
2328                                                 ADOConnection::outp( $this->db->ErrorMsg() );
2329                                         }
2330
2331                                         $this->success = 1;
2332                                 }
2333                         }
2334
2335                         return TRUE;
2336                 }
2337
2338                 return FALSE;
2339         }
2340
2341         /**
2342         * Gets the SQL array in the specified format.
2343         *
2344         * @param string $format Format
2345         * @return mixed SQL
2346         *
2347         * @access private
2348         */
2349         function getSQL( $format = NULL, $sqlArray = NULL ) {
2350                 if( !is_array( $sqlArray ) ) {
2351                         $sqlArray = $this->sqlArray;
2352                 }
2353
2354                 if( !is_array( $sqlArray ) ) {
2355                         return FALSE;
2356                 }
2357
2358                 switch( strtolower( $format ) ) {
2359                         case 'string':
2360                         case 'text':
2361                                 return !empty( $sqlArray ) ? implode( ";\n\n", $sqlArray ) . ';' : '';
2362                         case'html':
2363                                 return !empty( $sqlArray ) ? nl2br( htmlentities( implode( ";\n\n", $sqlArray ) . ';' ) ) : '';
2364                 }
2365
2366                 return $this->sqlArray;
2367         }
2368
2369         /**
2370         * Destroys an adoSchema object.
2371         *
2372         * Call this method to clean up after an adoSchema object that is no longer in use.
2373         * @deprecated adoSchema now cleans up automatically.
2374         */
2375         function Destroy() {
2376                 set_magic_quotes_runtime( $this->mgq );
2377                 unset( $this );
2378         }
2379 }
2380
2381 /**
2382 * Message logging function
2383 *
2384 * @access private
2385 */
2386 function logMsg( $msg, $title = NULL, $force = FALSE ) {
2387         if( XMLS_DEBUG or $force ) {
2388                 echo '<pre>';
2389
2390                 if( isset( $title ) ) {
2391                         echo '<h3>' . htmlentities( $title ) . '</h3>';
2392                 }
2393
2394                 if( @is_object( $this ) ) {
2395                         echo '[' . get_class( $this ) . '] ';
2396                 }
2397
2398                 print_r( $msg );
2399
2400                 echo '</pre>';
2401         }
2402 }
2403 ?>