library/adodb/adodb-xmlschema.inc.php

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