home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2008 February / PCWFEB08.iso / Software / Resources / Developers / XAMPP 1.5.4 / Windows installer / xampp-win32-1.5.4-installer.exe / xampp / php / pear / adodb / adodb-xmlschema03.inc.php < prev    next >
Encoding:
PHP Script  |  2006-08-02  |  61.2 KB  |  2,403 lines
  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: jlim $
  14.  * @author Richard Tango-Lowy & Dan Cech
  15.  * @version $Revision: 1.62 $
  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: 1.62 $
  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. ?>