/lib/rdfapi-php/api/util/adodb/adodb-xmlschema.inc.php

Large files files are truncated, but you can click here to view the full file

<?php

// Copyright (c) 2004 ars Cognita Inc., all rights reserved

/* ******************************************************************************

    Released under both BSD license and Lesser GPL library license. 

 	Whenever there is any discrepancy between the two licenses, 

 	the BSD license will take precedence. 

*******************************************************************************/

/**

 * xmlschema is a class that allows the user to quickly and easily

 * build a database on any ADOdb-supported platform using a simple

 * XML schema.

 *

 * Last Editor: $Author: tgauss $

 * @author Richard Tango-Lowy & Dan Cech

 * @version $Revision: 1.3 $

 *

 * @package axmls

 * @tutorial getting_started.pkg

 */



/**

* Debug on or off

*/

if( !defined( 'XMLS_DEBUG' ) ) {

	define( 'XMLS_DEBUG', FALSE );

}



/**

* Default prefix key

*/

if( !defined( 'XMLS_PREFIX' ) ) {

	define( 'XMLS_PREFIX', '%%P' );

}



/**

* Maximum length allowed for object prefix

*/

if( !defined( 'XMLS_PREFIX_MAXLEN' ) ) {

	define( 'XMLS_PREFIX_MAXLEN', 10 );

}



/**

* Execute SQL inline as it is generated

*/

if( !defined( 'XMLS_EXECUTE_INLINE' ) ) {

	define( 'XMLS_EXECUTE_INLINE', FALSE );

}



/**

* Continue SQL Execution if an error occurs?

*/

if( !defined( 'XMLS_CONTINUE_ON_ERROR' ) ) {

	define( 'XMLS_CONTINUE_ON_ERROR', FALSE );

}



/**

* Current Schema Version

*/

if( !defined( 'XMLS_SCHEMA_VERSION' ) ) {

	define( 'XMLS_SCHEMA_VERSION', '0.2' );

}



/**

* Default Schema Version.  Used for Schemas without an explicit version set.

*/

if( !defined( 'XMLS_DEFAULT_SCHEMA_VERSION' ) ) {

	define( 'XMLS_DEFAULT_SCHEMA_VERSION', '0.1' );

}



/**

* Default Schema Version.  Used for Schemas without an explicit version set.

*/

if( !defined( 'XMLS_DEFAULT_UPGRADE_METHOD' ) ) {

	define( 'XMLS_DEFAULT_UPGRADE_METHOD', 'ALTER' );

}



/**

* Include the main ADODB library

*/

if( !defined( '_ADODB_LAYER' ) ) {

	require( 'adodb.inc.php' );

	require( 'adodb-datadict.inc.php' );

}



/**

* Abstract DB Object. This class provides basic methods for database objects, such

* as tables and indexes.

*

* @package axmls

* @access private

*/

class dbObject {

	

	/**

	* var object Parent

	*/

	var $parent;

	

	/**

	* var string current element

	*/

	var $currentElement;

	

	/**

	* NOP

	*/

	function dbObject( &$parent, $attributes = NULL ) {

		$this->parent =& $parent;

	}

	

	/**

	* XML Callback to process start elements

	*

	* @access private

	*/

	function _tag_open( &$parser, $tag, $attributes ) {

		

	}

	

	/**

	* XML Callback to process CDATA elements

	*

	* @access private

	*/

	function _tag_cdata( &$parser, $cdata ) {

		

	}

	

	/**

	* XML Callback to process end elements

	*

	* @access private

	*/

	function _tag_close( &$parser, $tag ) {

		

	}

	

	function create() {

		return array();

	}

	

	/**

	* Destroys the object

	*/

	function destroy() {

		unset( $this );

	}

	

	/**

	* Checks whether the specified RDBMS is supported by the current

	* database object or its ranking ancestor.

	*

	* @param string $platform RDBMS platform name (from ADODB platform list).

	* @return boolean TRUE if RDBMS is supported; otherwise returns FALSE.

	*/

	function supportedPlatform( $platform = NULL ) {

		return is_object( $this->parent ) ? $this->parent->supportedPlatform( $platform ) : TRUE;

	}

	

	/**

	* Returns the prefix set by the ranking ancestor of the database object.

	*

	* @param string $name Prefix string.

	* @return string Prefix.

	*/

	function prefix( $name = '' ) {

		return is_object( $this->parent ) ? $this->parent->prefix( $name ) : $name;

	}

	

	/**

	* Extracts a field ID from the specified field.

	*

	* @param string $field Field.

	* @return string Field ID.

	*/

	function FieldID( $field ) {

		return strtoupper( preg_replace( '/^`(.+)`$/', '$1', $field ) );

	}

}



/**

* Creates a table object in ADOdb's datadict format

*

* This class stores information about a database table. As charactaristics

* of the table are loaded from the external source, methods and properties

* of this class are used to build up the table description in ADOdb's

* datadict format.

*

* @package axmls

* @access private

*/

class dbTable extends dbObject {

	

	/**

	* @var string Table name

	*/

	var $name;

	

	/**

	* @var array Field specifier: Meta-information about each field

	*/

	var $fields = array();

	

	/**

	* @var array List of table indexes.

	*/

	var $indexes = array();

	

	/**

	* @var array Table options: Table-level options

	*/

	var $opts = array();

	

	/**

	* @var string Field index: Keeps track of which field is currently being processed

	*/

	var $current_field;

	

	/**

	* @var boolean Mark table for destruction

	* @access private

	*/

	var $drop_table;

	

	/**

	* @var boolean Mark field for destruction (not yet implemented)

	* @access private

	*/

	var $drop_field = array();

	

	/**

	* Iniitializes a new table object.

	*

	* @param string $prefix DB Object prefix

	* @param array $attributes Array of table attributes.

	*/

	function dbTable( &$parent, $attributes = NULL ) {

		$this->parent =& $parent;

		$this->name = $this->prefix($attributes['NAME']);

	}

	

	/**

	* XML Callback to process start elements. Elements currently 

	* processed are: INDEX, DROP, FIELD, KEY, NOTNULL, AUTOINCREMENT & DEFAULT. 

	*

	* @access private

	*/

	function _tag_open( &$parser, $tag, $attributes ) {

		$this->currentElement = strtoupper( $tag );

		

		switch( $this->currentElement ) {

			case 'INDEX':

				if( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) ) {

					xml_set_object( $parser, $this->addIndex( $attributes ) );

				}

				break;

			case 'DATA':

				if( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) ) {

					xml_set_object( $parser, $this->addData( $attributes ) );

				}

				break;

			case 'DROP':

				$this->drop();

				break;

			case 'FIELD':

				// Add a field

				$fieldName = $attributes['NAME'];

				$fieldType = $attributes['TYPE'];

				$fieldSize = isset( $attributes['SIZE'] ) ? $attributes['SIZE'] : NULL;

				$fieldOpts = isset( $attributes['OPTS'] ) ? $attributes['OPTS'] : NULL;

				

				$this->addField( $fieldName, $fieldType, $fieldSize, $fieldOpts );

				break;

			case 'KEY':

			case 'NOTNULL':

			case 'AUTOINCREMENT':

				// Add a field option

				$this->addFieldOpt( $this->current_field, $this->currentElement );

				break;

			case 'DEFAULT':

				// Add a field option to the table object

				

				// Work around ADOdb datadict issue that misinterprets empty strings.

				if( $attributes['VALUE'] == '' ) {

					$attributes['VALUE'] = " '' ";

				}

				

				$this->addFieldOpt( $this->current_field, $this->currentElement, $attributes['VALUE'] );

				break;

			case 'DEFDATE':

			case 'DEFTIMESTAMP':

				// Add a field option to the table object

				$this->addFieldOpt( $this->current_field, $this->currentElement );

				break;

			default:

				// print_r( array( $tag, $attributes ) );

		}

	}

	

	/**

	* XML Callback to process CDATA elements

	*

	* @access private

	*/

	function _tag_cdata( &$parser, $cdata ) {

		switch( $this->currentElement ) {

			// Table constraint

			case 'CONSTRAINT':

				if( isset( $this->current_field ) ) {

					$this->addFieldOpt( $this->current_field, $this->currentElement, $cdata );

				} else {

					$this->addTableOpt( $cdata );

				}

				break;

			// Table option

			case 'OPT':

				$this->addTableOpt( $cdata );

				break;

			default:

				

		}

	}

	

	/**

	* XML Callback to process end elements

	*

	* @access private

	*/

	function _tag_close( &$parser, $tag ) {

		$this->currentElement = '';

		

		switch( strtoupper( $tag ) ) {

			case 'TABLE':

				$this->parent->addSQL( $this->create( $this->parent ) );

				xml_set_object( $parser, $this->parent );

				$this->destroy();

				break;

			case 'FIELD':

				unset($this->current_field);

				break;



		}

	}

	

	/**

	* Adds an index to a table object

	*

	* @param array $attributes Index attributes

	* @return object dbIndex object

	*/

	function &addIndex( $attributes ) {

		$name = strtoupper( $attributes['NAME'] );

		$this->indexes[$name] =& new dbIndex( $this, $attributes );

		return $this->indexes[$name];

	}

	

	/**

	* Adds data to a table object

	*

	* @param array $attributes Data attributes

	* @return object dbData object

	*/

	function &addData( $attributes ) {

		if( !isset( $this->data ) ) {

			$this->data =& new dbData( $this, $attributes );

		}

		return $this->data;

	}

	

	/**

	* Adds a field to a table object

	*

	* $name is the name of the table to which the field should be added. 

	* $type is an ADODB datadict field type. The following field types

	* are supported as of ADODB 3.40:

	* 	- C:  varchar

	*	- X:  CLOB (character large object) or largest varchar size

	*	   if CLOB is not supported

	*	- C2: Multibyte varchar

	*	- X2: Multibyte CLOB

	*	- B:  BLOB (binary large object)

	*	- D:  Date (some databases do not support this, and we return a datetime type)

	*	- T:  Datetime or Timestamp

	*	- L:  Integer field suitable for storing booleans (0 or 1)

	*	- I:  Integer (mapped to I4)

	*	- I1: 1-byte integer

	*	- I2: 2-byte integer

	*	- I4: 4-byte integer

	*	- I8: 8-byte integer

	*	- F:  Floating point number

	*	- N:  Numeric or decimal number

	*

	* @param string $name Name of the table to which the field will be added.

	* @param string $type	ADODB datadict field type.

	* @param string $size	Field size

	* @param array $opts	Field options array

	* @return array Field specifier array

	*/

	function addField( $name, $type, $size = NULL, $opts = NULL ) {

		$field_id = $this->FieldID( $name );

		

		// Set the field index so we know where we are

		$this->current_field = $field_id;

		

		// Set the field name (required)

		$this->fields[$field_id]['NAME'] = $name;

		

		// Set the field type (required)

		$this->fields[$field_id]['TYPE'] = $type;

		

		// Set the field size (optional)

		if( isset( $size ) ) {

			$this->fields[$field_id]['SIZE'] = $size;

		}

		

		// Set the field options

		if( isset( $opts ) ) {

			$this->fields[$field_id]['OPTS'][] = $opts;

		}

	}

	

	/**

	* Adds a field option to the current field specifier

	*

	* This method adds a field option allowed by the ADOdb datadict 

	* and appends it to the given field.

	*

	* @param string $field	Field name

	* @param string $opt ADOdb field option

	* @param mixed $value Field option value

	* @return array Field specifier array

	*/

	function addFieldOpt( $field, $opt, $value = NULL ) {

		if( !isset( $value ) ) {

			$this->fields[$this->FieldID( $field )]['OPTS'][] = $opt;

		// Add the option and value

		} else {

			$this->fields[$this->FieldID( $field )]['OPTS'][] = array( $opt => $value );

		}

	}

	

	/**

	* Adds an option to the table

	*

	* This method takes a comma-separated list of table-level options

	* and appends them to the table object.

	*

	* @param string $opt Table option

	* @return array Options

	*/

	function addTableOpt( $opt ) {

		$this->opts[] = $opt;

		

		return $this->opts;

	}

	

	/**

	* Generates the SQL that will create the table in the database

	*

	* @param object $xmls adoSchema object

	* @return array Array containing table creation SQL

	*/

	function create( &$xmls ) {

		$sql = array();

		

		// drop any existing indexes

		if( is_array( $legacy_indexes = $xmls->dict->MetaIndexes( $this->name ) ) ) {

			foreach( $legacy_indexes as $index => $index_details ) {

				$sql[] = $xmls->dict->DropIndexSQL( $index, $this->name );

			}

		}

		

		// remove fields to be dropped from table object

		foreach( $this->drop_field as $field ) {

			unset( $this->fields[$field] );

		}

		

		// if table exists

		if( is_array( $legacy_fields = $xmls->dict->MetaColumns( $this->name ) ) ) {

			// drop table

			if( $this->drop_table ) {

				$sql[] = $xmls->dict->DropTableSQL( $this->name );

				

				return $sql;

			}

			

			// drop any existing fields not in schema

			foreach( $legacy_fields as $field_id => $field ) {

				if( !isset( $this->fields[$field_id] ) ) {

					$sql[] = $xmls->dict->DropColumnSQL( $this->name, '`'.$field->name.'`' );

				}

			}

		// if table doesn't exist

		} else {

			if( $this->drop_table ) {

				return $sql;

			}

			

			$legacy_fields = array();

		}

		

		// Loop through the field specifier array, building the associative array for the field options

		$fldarray = array();

		

		foreach( $this->fields as $field_id => $finfo ) {

			// Set an empty size if it isn't supplied

			if( !isset( $finfo['SIZE'] ) ) {

				$finfo['SIZE'] = '';

			}

			

			// Initialize the field array with the type and size

			$fldarray[$field_id] = array(

				'NAME' => $finfo['NAME'],

				'TYPE' => $finfo['TYPE'],

				'SIZE' => $finfo['SIZE']

			);

			

			// Loop through the options array and add the field options. 

			if( isset( $finfo['OPTS'] ) ) {

				foreach( $finfo['OPTS'] as $opt ) {

					// Option has an argument.

					if( is_array( $opt ) ) {

						$key = key( $opt );

						$value = $opt[key( $opt )];

						@$fldarray[$field_id][$key] .= $value;

					// Option doesn't have arguments

					} else {

						$fldarray[$field_id][$opt] = $opt;

					}

				}

			}

		}

		

		if( empty( $legacy_fields ) ) {

			// Create the new table

			$sql[] = $xmls->dict->CreateTableSQL( $this->name, $fldarray, $this->opts );

			logMsg( end( $sql ), 'Generated CreateTableSQL' );

		} else {

			// Upgrade an existing table

			logMsg( "Upgrading {$this->name} using '{$xmls->upgrade}'" );

			switch( $xmls->upgrade ) {

				// Use ChangeTableSQL

				case 'ALTER':

					logMsg( 'Generated ChangeTableSQL (ALTERing table)' );

					$sql[] = $xmls->dict->ChangeTableSQL( $this->name, $fldarray, $this->opts );

					break;

				case 'REPLACE':

					logMsg( 'Doing upgrade REPLACE (testing)' );

					$sql[] = $xmls->dict->DropTableSQL( $this->name );

					$sql[] = $xmls->dict->CreateTableSQL( $this->name, $fldarray, $this->opts );

					break;

				// ignore table

				default:

					return array();

			}

		}

		

		foreach( $this->indexes as $index ) {

			$sql[] = $index->create( $xmls );

		}

		

		if( isset( $this->data ) ) {

			$sql[] = $this->data->create( $xmls );

		}

		

		return $sql;

	}

	

	/**

	* Marks a field or table for destruction

	*/

	function drop() {

		if( isset( $this->current_field ) ) {

			// Drop the current field

			logMsg( "Dropping field '{$this->current_field}' from table '{$this->name}'" );

			// $this->drop_field[$this->current_field] = $xmls->dict->DropColumnSQL( $this->name, $this->current_field );

			$this->drop_field[$this->current_field] = $this->current_field;

		} else {

			// Drop the current table

			logMsg( "Dropping table '{$this->name}'" );

			// $this->drop_table = $xmls->dict->DropTableSQL( $this->name );

			$this->drop_table = TRUE;

		}

	}

}



/**

* Creates an index object in ADOdb's datadict format

*

* This class stores information about a database index. As charactaristics

* of the index are loaded from the external source, methods and properties

* of this class are used to build up the index description in ADOdb's

* datadict format.

*

* @package axmls

* @access private

*/

class dbIndex extends dbObject {

	

	/**

	* @var string	Index name

	*/

	var $name;

	

	/**

	* @var array	Index options: Index-level options

	*/

	var $opts = array();

	

	/**

	* @var array	Indexed fields: Table columns included in this index

	*/

	var $columns = array();

	

	/**

	* @var boolean Mark index for destruction

	* @access private

	*/

	var $drop = FALSE;

	

	/**

	* Initializes the new dbIndex object.

	*

	* @param object $parent Parent object

	* @param array $attributes Attributes

	*

	* @internal

	*/

	function dbIndex( &$parent, $attributes = NULL ) {

		$this->parent =& $parent;

		

		$this->name = $this->prefix ($attributes['NAME']);

	}

	

	/**

	* XML Callback to process start elements

	*

	* Processes XML opening tags. 

	* Elements currently processed are: DROP, CLUSTERED, BITMAP, UNIQUE, FULLTEXT & HASH. 

	*

	* @access private

	*/

	function _tag_open( &$parser, $tag, $attributes ) {

		$this->currentElement = strtoupper( $tag );

		

		switch( $this->currentElement ) {

			case 'DROP':

				$this->drop();

				break;

			case 'CLUSTERED':

			case 'BITMAP':

			case 'UNIQUE':

			case 'FULLTEXT':

			case 'HASH':

				// Add index Option

				$this->addIndexOpt( $this->currentElement );

				break;

			default:

				// print_r( array( $tag, $attributes ) );

		}

	}

	

	/**

	* XML Callback to process CDATA elements

	*

	* Processes XML cdata.

	*

	* @access private

	*/

	function _tag_cdata( &$parser, $cdata ) {

		switch( $this->currentElement ) {

			// Index field name

			case 'COL':

				$this->addField( $cdata );

				break;

			default:

				

		}

	}

	

	/**

	* XML Callback to process end elements

	*

	* @access private

	*/

	function _tag_close( &$parser, $tag ) {

		$this->currentElement = '';

		

		switch( strtoupper( $tag ) ) {

			case 'INDEX':

				xml_set_object( $parser, $this->parent );

				break;

		}

	}

	

	/**

	* Adds a field to the index

	*

	* @param string $name Field name

	* @return string Field list

	*/

	function addField( $name ) {

		$this->columns[$this->FieldID( $name )] = $name;

		

		// Return the field list

		return $this->columns;

	}

	

	/**

	* Adds options to the index

	*

	* @param string $opt Comma-separated list of index options.

	* @return string Option list

	*/

	function addIndexOpt( $opt ) {

		$this->opts[] = $opt;

		

		// Return the options list

		return $this->opts;

	}

	

	/**

	* Generates the SQL that will create the index in the database

	*

	* @param object $xmls adoSchema object

	* @return array Array containing index creation SQL

	*/

	function create( &$xmls ) {

		if( $this->drop ) {

			return NULL;

		}

		

		// eliminate any columns that aren't in the table

		foreach( $this->columns as $id => $col ) {

			if( !isset( $this->parent->fields[$id] ) ) {

				unset( $this->columns[$id] );

			}

		}

		

		return $xmls->dict->CreateIndexSQL( $this->name, $this->parent->name, $this->columns, $this->opts );

	}

	

	/**

	* Marks an index for destruction

	*/

	function drop() {

		$this->drop = TRUE;

	}

}



/**

* Creates a data object in ADOdb's datadict format

*

* This class stores information about table data.

*

* @package axmls

* @access private

*/

class dbData extends dbObject {

	

	var $data = array();

	

	var $row;

	

	/**

	* Initializes the new dbIndex object.

	*

	* @param object $parent Parent object

	* @param array $attributes Attributes

	*

	* @internal

	*/

	function dbData( &$parent, $attributes = NULL ) {

		$this->parent =& $parent;

	}

	

	/**

	* XML Callback to process start elements

	*

	* Processes XML opening tags. 

	* Elements currently processed are: DROP, CLUSTERED, BITMAP, UNIQUE, FULLTEXT & HASH. 

	*

	* @access private

	*/

	function _tag_open( &$parser, $tag, $attributes ) {

		$this->currentElement = strtoupper( $tag );

		

		switch( $this->currentElement ) {

			case 'ROW':

				$this->row = count( $this->data );

				$this->data[$this->row] = array();

				break;

			case 'F':

				$this->addField($attributes);

			default:

				// print_r( array( $tag, $attributes ) );

		}

	}

	

	/**

	* XML Callback to process CDATA elements

	*

	* Processes XML cdata.

	*

	* @access private

	*/

	function _tag_cdata( &$parser, $cdata ) {

		switch( $this->currentElement ) {

			// Index field name

			case 'F':

				$this->addData( $cdata );

				break;

			default:

				

		}

	}

	

	/**

	* XML Callback to process end elements

	*

	* @access private

	*/

	function _tag_close( &$parser, $tag ) {

		$this->currentElement = '';

		

		switch( strtoupper( $tag ) ) {

			case 'DATA':

				xml_set_object( $parser, $this->parent );

				break;

		}

	}

	

	/**

	* Adds a field to the index

	*

	* @param string $name Field name

	* @return string Field list

	*/

	function addField( $attributes ) {

		if( isset( $attributes['NAME'] ) ) {

			$name = $attributes['NAME'];

		} else {

			$name = count($this->data[$this->row]);

		}

		

		// Set the field index so we know where we are

		$this->current_field = $this->FieldID( $name );

	}

	

	/**

	* Adds options to the index

	*

	* @param string $opt Comma-separated list of index options.

	* @return string Option list

	*/

	function addData( $cdata ) {

		if( !isset( $this->data[$this->row] ) ) {

			$this->data[$this->row] = array();

		}

		

		if( !isset( $this->data[$this->row][$this->current_field] ) ) {

			$this->data[$this->row][$this->current_field] = '';

		}

		

		$this->data[$this->row][$this->current_field] .= $cdata;

	}

	

	/**

	* Generates the SQL that will create the index in the database

	*

	* @param object $xmls adoSchema object

	* @return array Array containing index creation SQL

	*/

	function create( &$xmls ) {

		$table = $xmls->dict->TableName($this->parent->name);

		$table_field_count = count($this->parent->fields);

		$sql = array();

		

		// eliminate any columns that aren't in the table

		foreach( $this->data as $row ) {

			$table_fields = $this->parent->fields;

			$fields = array();

			

			foreach( $row as $field_id => $field_data ) {

				if( !array_key_exists( $field_id, $table_fields ) ) {

					if( is_numeric( $field_id ) ) {

						$field_id = reset( array_keys( $table_fields ) );

					} else {

						continue;

					}

				}

				

				$name = $table_fields[$field_id]['NAME'];

				

				switch( $table_fields[$field_id]['TYPE'] ) {

					case 'C':

					case 'C2':

					case 'X':

					case 'X2':

						$fields[$name] = $xmls->db->qstr( $field_data );

						break;

					case 'I':

					case 'I1':

					case 'I2':

					case 'I4':

					case 'I8':

						$fields[$name] = intval($field_data);

						break;

					default:

						$fields[$name] = $field_data;

				}

				

				unset($table_fields[$field_id]);

			}

			

			// check that at least 1 column is specified

			if( empty( $fields ) ) {

				continue;

			}

			

			// check that no required columns are missing

			if( count( $fields ) < $table_field_count ) {

				foreach( $table_fields as $field ) {

					if( ( in_array( 'NOTNULL', $field['OPTS'] ) || in_array( 'KEY', $field['OPTS'] ) ) && !in_array( 'AUTOINCREMENT', $field['OPTS'] ) ) {

						continue(2);

					}

				}

			}

			

			$sql[] = 'INSERT INTO '. $table .' ('. implode( ',', array_keys( $fields ) ) .') VALUES ('. implode( ',', $fields ) .')';

		}

		

		return $sql;

	}

}



/**

* Creates the SQL to execute a list of provided SQL queries

*

* @package axmls

* @access private

*/

class dbQuerySet extends dbObject {

	

	/**

	* @var array	List of SQL queries

	*/

	var $queries = array();

	

	/**

	* @var string	String used to build of a query line by line

	*/

	var $query;

	

	/**

	* @var string	Query prefix key

	*/

	var $prefixKey = '';

	

	/**

	* @var boolean	Auto prefix enable (TRUE)

	*/

	var $prefixMethod = 'AUTO';

	

	/**

	* Initializes the query set.

	*

	* @param object $parent Parent object

	* @param array $attributes Attributes

	*/

	function dbQuerySet( &$parent, $attributes = NULL ) {

		$this->parent =& $parent;

			

		// Overrides the manual prefix key

		if( isset( $attributes['KEY'] ) ) {

			$this->prefixKey = $attributes['KEY'];

		}

		

		$prefixMethod = isset( $attributes['PREFIXMETHOD'] ) ? strtoupper( trim( $attributes['PREFIXMETHOD'] ) ) : '';

		

		// Enables or disables automatic prefix prepending

		switch( $prefixMethod ) {

			case 'AUTO':

				$this->prefixMethod = 'AUTO';

				break;

			case 'MANUAL':

				$this->prefixMethod = 'MANUAL';

				break;

			case 'NONE':

				$this->prefixMethod = 'NONE';

				break;

		}

	}

	

	/**

	* XML Callback to process start elements. Elements currently 

	* processed are: QUERY. 

	*

	* @access private

	*/

	function _tag_open( &$parser, $tag, $attributes ) {

		$this->currentElement = strtoupper( $tag );

		

		switch( $this->currentElement ) {

			case 'QUERY':

				// Create a new query in a SQL queryset.

				// Ignore this query set if a platform is specified and it's different than the 

				// current connection platform.

				if( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) ) {

					$this->newQuery();

				} else {

					$this->discardQuery();

				}

				break;

			default:

				// print_r( array( $tag, $attributes ) );

		}

	}

	

	/**

	* XML Callback to process CDATA elements

	*/

	function _tag_cdata( &$parser, $cdata ) {

		switch( $this->currentElement ) {

			// Line of queryset SQL data

			case 'QUERY':

				$this->buildQuery( $cdata );

				break;

			default:

				

		}

	}

	

	/**

	* XML Callback to process end elements

	*

	* @access private

	*/

	function _tag_close( &$parser, $tag ) {

		$this->currentElement = '';

		

		switch( strtoupper( $tag ) ) {

			case 'QUERY':

				// Add the finished query to the open query set.

				$this->addQuery();

				break;

			case 'SQL':

				$this->parent->addSQL( $this->create( $this->parent ) );

				xml_set_object( $parser, $this->parent );

				$this->destroy();

				break;

			default:

				

		}

	}

	

	/**

	* Re-initializes the query.

	*

	* @return boolean TRUE

	*/

	function newQuery() {

		$this->query = '';

		

		return TRUE;

	}

	

	/**

	* Discards the existing query.

	*

	* @return boolean TRUE

	*/

	function discardQuery() {

		unset( $this->query );

		

		return TRUE;

	}

	

	/** 

	* Appends a line to a query that is being built line by line

	*

	* @param string $data Line of SQL data or NULL to initialize a new query

	* @return string SQL query string.

	*/

	function buildQuery( $sql = NULL ) {

		if( !isset( $this->query ) OR empty( $sql ) ) {

			return FALSE;

		}

		

		$this->query .= $sql;

		

		return $this->query;

	}

	

	/**

	* Adds a completed query to the query list

	*

	* @return string	SQL of added query

	*/

	function addQuery() {

		if( !isset( $this->query ) ) {

			return FALSE;

		}

		

		$this->queries[] = $return = trim($this->query);

		

		unset( $this->query );

		

		return $return;

	}

	

	/**

	* Creates and returns the current query set

	*

	* @param object $xmls adoSchema object

	* @return array Query set

	*/

	function create( &$xmls ) {

		foreach( $this->queries as $id => $query ) {

			switch( $this->prefixMethod ) {

				case 'AUTO':

					// Enable auto prefix replacement

					

					// Process object prefix.

					// Evaluate SQL statements to prepend prefix to objects

					$query = $this->prefixQuery( '/^\s*((?is)INSERT\s+(INTO\s+)?)((\w+\s*,?\s*)+)(\s.*$)/', $query, $xmls->objectPrefix );

					$query = $this->prefixQuery( '/^\s*((?is)UPDATE\s+(FROM\s+)?)((\w+\s*,?\s*)+)(\s.*$)/', $query, $xmls->objectPrefix );

					$query = $this->prefixQuery( '/^\s*((?is)DELETE\s+(FROM\s+)?)((\w+\s*,?\s*)+)(\s.*$)/', $query, $xmls->objectPrefix );

					

					// SELECT statements aren't working yet

					#$data = preg_replace( '/(?ias)(^\s*SELECT\s+.*\s+FROM)\s+(\W\s*,?\s*)+((?i)\s+WHERE.*$)/', "\1 $prefix\2 \3", $data );

					

				case 'MANUAL':

					// If prefixKey is set and has a value then we use it to override the default constant XMLS_PREFIX.

					// If prefixKey is not set, we use the default constant XMLS_PREFIX

					if( isset( $this->prefixKey ) AND( $this->prefixKey !== '' ) ) {

						// Enable prefix override

						$query = str_replace( $this->prefixKey, $xmls->objectPrefix, $query );

					} else {

						// Use default replacement

						$query = str_replace( XMLS_PREFIX , $xmls->objectPrefix, $query );

					}

			}

			

			$this->queries[$id] = trim( $query );

		}

		

		// Return the query set array

		return $this->queries;

	}

	

	/**

	* Rebuilds the query with the prefix attached to any objects

	*

	* @param string $regex Regex used to add prefix

	* @param string $query SQL query string

	* @param string $prefix Prefix to be appended to tables, indices, etc.

	* @return string Prefixed SQL query string.

	*/

	function prefixQuery( $regex, $query, $prefix = NULL ) {

		if( !isset( $prefix ) ) {

			return $query;

		}

		

		if( preg_match( $regex, $query, $match ) ) {

			$preamble = $match[1];

			$postamble = $match[5];

			$objectList = explode( ',', $match[3] );

			// $prefix = $prefix . '_';

			

			$prefixedList = '';

			

			foreach( $objectList as $object ) {

				if( $prefixedList !== '' ) {

					$prefixedList .= ', ';

				}

				

				$prefixedList .= $prefix . trim( $object );

			}

			

			$query = $preamble . ' ' . $prefixedList . ' ' . $postamble;

		}

		

		return $query;

	}

}



/**

* Loads and parses an XML file, creating an array of "ready-to-run" SQL statements

* 

* This class is used to load and parse the XML file, to create an array of SQL statements

* that can be used to build a database, and to build the database using the SQL array.

*

* @tutorial getting_started.pkg

*

* @author Richard Tango-Lowy & Dan Cech

* @version $Revision: 1.3 $

*

* @package axmls

*/

class adoSchema {

	

	/**

	* @var array	Array containing SQL queries to generate all objects

	* @access private

	*/

	var $sqlArray;

	

	/**

	* @var object	ADOdb connection object

	* @access private

	*/

	var $db;

	

	/**

	* @var object	ADOdb Data Dictionary

	* @access private

	*/

	var $dict;

	

	/**

	* @var string Current XML element

	* @access private

	*/

	var $currentElement = '';

	

	/**

	* @var string If set (to 'ALTER' or 'REPLACE'), upgrade an existing database

	* @access private

	*/

	var $upgrade = '';

	

	/**

	* @var string Optional object prefix

	* @access private

	*/

	var $objectPrefix = '';

	

	/**

	* @var long	Original Magic Quotes Runtime value

	* @access private

	*/

	var $mgq;

	

	/**

	* @var long	System debug

	* @access private

	*/

	var $debug;

	

	/**

	* @var string Regular expression to find schema version

	* @access private

	*/

	var $versionRegex = '/<schema.*?( version="([^"]*)")?.*?>/';

	

	/**

	* @var string Current schema version

	* @access private

	*/

	var $schemaVersion;

	

	/**

	* @var int	Success of last Schema execution

	*/

	var $success;

	

	/**

	* @var bool	Execute SQL inline as it is generated

	*/

	var $executeInline;

	

	/**

	* @var bool	Continue SQL execution if errors occur

	*/

	var $continueOnError;

	

	/**

	* Creates an adoSchema object

	*

	* Creating an adoSchema object is the first step in processing an XML schema.

	* The only parameter is an ADOdb database connection object, which must already

	* have been created.

	*

	* @param object $db ADOdb database connection object.

	*/

	function adoSchema( &$db ) {

		// Initialize the environment

		$this->mgq = get_magic_quotes_runtime();

		set_magic_quotes_runtime(0);

		

		$this->db =& $db;

		$this->debug = $this->db->debug;

		$this->dict = NewDataDictionary( $this->db );

		$this->sqlArray = array();

		$this->schemaVersion = XMLS_SCHEMA_VERSION;

		$this->executeInline( XMLS_EXECUTE_INLINE );

		$this->continueOnError( XMLS_CONTINUE_ON_ERROR );

		$this->setUpgradeMethod();

	}

	

	/**

	* Sets the method to be used for upgrading an existing database

	*

	* Use this method to specify how existing database objects should be upgraded.

	* The method option can be set to ALTER, REPLACE, BEST, or NONE. ALTER attempts to

	* alter each database object directly, REPLACE attempts to rebuild each object

	* from scratch, BEST attempts to determine the best upgrade method for each

	* object, and NONE disables upgrading.

	*

	* This method is not yet used by AXMLS, but exists for backward compatibility.

	* The ALTER method is automatically assumed when the adoSchema object is

	* instantiated; other upgrade methods are not currently supported.

	*

	* @param string $method Upgrade method (ALTER|REPLACE|BEST|NONE)

	* @returns string Upgrade method used

	*/

	function SetUpgradeMethod( $method = '' ) {

		if( !is_string( $method ) ) {

			return FALSE;

		}

		

		$method = strtoupper( $method );

		

		// Handle the upgrade methods

		switch( $method ) {

			case 'ALTER':

				$this->upgrade = $method;

				break;

			case 'REPLACE':

				$this->upgrade = $method;

				break;

			case 'BEST':

				$this->upgrade = 'ALTER';

				break;

			case 'NONE':

				$this->upgrade = 'NONE';

				break;

			default:

				// Use default if no legitimate method is passed.

				$this->upgrade = XMLS_DEFAULT_UPGRADE_METHOD;

		}

		

		return $this->upgrade;

	}

	

	/**

	* Enables/disables inline SQL execution.

	*

	* Call this method to enable or disable inline execution of the schema. If the mode is set to TRUE (inline execution),

	* AXMLS applies the SQL to the database immediately as each schema entity is parsed. If the mode

	* is set to FALSE (post execution), AXMLS parses the entire schema and you will need to call adoSchema::ExecuteSchema()

	* to apply the schema to the database.

	*

	* @param bool $mode execute

	* @return bool current execution mode

	*

	* @see ParseSchema(), ExecuteSchema()

	*/

	function ExecuteInline( $mode = NULL ) {

		if( is_bool( $mode ) ) {

			$this->executeInline = $mode;

		}

		

		return $this->executeInline;

	}

	

	/**

	* Enables/disables SQL continue on error.

	*

	* Call this method to enable or disable continuation of SQL execution if an error occurs.

	* If the mode is set to TRUE (continue), AXMLS will continue to apply SQL to the database, even if an error occurs.

	* If the mode is set to FALSE (halt), AXMLS will halt execution of generated sql if an error occurs, though parsing

	* of the schema will continue.

	*

	* @param bool $mode execute

	* @return bool current continueOnError mode

	*

	* @see addSQL(), ExecuteSchema()

	*/

	function ContinueOnError( $mode = NULL ) {

		if( is_bool( $mode ) ) {

			$this->continueOnError = $mode;

		}

		

		return $this->continueOnError;

	}

	

	/**

	* Loads an XML schema from a file and converts it to SQL.

	*

	* Call this method to load the specified schema (see the DTD for the proper format) from

	* the filesystem and generate the SQL necessary to create the database described. 

	* @see ParseSchemaString()

	*

	* @param string $file Name of XML schema file.

	* @param bool $returnSchema Return schema rather than parsing.

	* @return array Array of SQL queries, ready to execute

	*/

	function ParseSchema( $filename, $returnSchema = FALSE ) {

		return $this->ParseSchemaString( $this->ConvertSchemaFile( $filename ), $returnSchema );

	}

	

	/**

	* Loads an XML schema from a file and converts it to SQL.

	*

	* Call this method to load the specified schema from a file (see the DTD for the proper format) 

	* and generate the SQL necessary to create the database described by the schema.

	*

	* @param string $file Name of XML schema file.

	* @param bool $returnSchema Return schema rather than parsing.

	* @return array Array of SQL queries, ready to execute.

	*

	* @deprecated Replaced by adoSchema::ParseSchema() and adoSchema::ParseSchemaString()

	* @see ParseSchema(), ParseSchemaString()

	*/

	function ParseSchemaFile( $filename, $returnSchema = FALSE ) {

		// Open the file

		if( !($fp = fopen( $filename, 'r' )) ) {

			// die( 'Unable to open file' );

			return FALSE;

		}

		

		// do version detection here

		if( $this->SchemaFileVersion( $filename ) != $this->schemaVersion ) {

			return FALSE;

		}

		

		if ( $returnSchema )

		{

			return $xmlstring;

		}

		

		$this->success = 2;

		

		$xmlParser = $this->create_parser();

		

		// Process the file

		while( $data = fread( $fp, 4096 ) ) {

			if( !xml_parse( $xmlParser, $data, feof( $fp ) ) ) {

				die( sprintf(

					"XML error: %s at line %d",

					xml_error_string( xml_get_error_code( $xmlParser) ),

					xml_get_current_line_number( $xmlParser)

				) );

			}

		}

		

		xml_parser_free( $xmlParser );

		

		return $this->sqlArray;

	}

	

	/**

	* Converts an XML schema string to SQL.

	*

	* Call this method to parse a string containing an XML schema (see the DTD for the proper format)

	* and generate the SQL necessary to create the database described by the schema. 

	* @see ParseSchema()

	*

	* @param string $xmlstring XML schema string.

	* @param bool $returnSchema Return schema rather than parsing.

	* @return array Array of SQL queries, ready to execute.

	*/

	function ParseSchemaString( $xmlstring, $returnSchema = FALSE ) {

		if( !is_string( $xmlstring ) OR empty( $xmlstring ) ) {

			return FALSE;

		}

		

		// do version detection here

		if( $this->SchemaStringVersion( $xmlstring ) != $this->schemaVersion ) {

			return FALSE;

		}

		

		if ( $returnSchema )

		{

			return $xmlstring;

		}

		

		$this->success = 2;

		

		$xmlParser = $this->create_parser();

		

		if( !xml_parse( $xmlParser, $xmlstring, TRUE ) ) {

			die( sprintf(

				"XML error: %s at line %d",

				xml_error_string( xml_get_error_code( $xmlParser) ),

				xml_get_current_line_number( $xmlParser)

			) );

		}

		

		xml_parser_free( $xmlParser );

		

		return $this->sqlArray;

	}

	

	/**

	* Loads an XML schema from a file and converts it to uninstallation SQL.

	*

	* Call this method to load the specified schema (see the DTD for the proper format) from

	* the filesystem and generate the SQL necessary to remove the database described.

	* @see RemoveSchemaString()

	*

	* @param string $file Name of XML schema file.

	* @param bool $returnSchema Return schema rather than parsing.

	* @return array Array of SQL queries, ready to execute

	*/

	function RemoveSchema( $filename, $returnSchema = FALSE ) {

		return $this->RemoveSchemaString( $this->ConvertSchemaFile( $filename ), $returnSchema );

	}

	

	/**

	* Converts an XML schema string to uninstallation SQL.

	*

	* Call this method to parse a string containing an XML schema (see the DTD for the proper format)

	* and generate the SQL necessary to uninstall the database described by the schema. 

	* @see RemoveSchema()

	*

	* @param string $schema XML schema string.

	* @param bool $returnSchema Return schema rather than parsing.

	* @return array Array of SQL queries, ready to execute.

	*/

	function RemoveSchemaString( $schema, $returnSchema = FALSE ) {

		

		// grab current version

		if( !( $version = $this->SchemaStringVersion( $schema ) ) ) {

			return FALSE;

		}

		

		return $this->ParseSchemaString( $this->TransformSchema( $schema, 'remove-' . $version), $returnSchema );

	}

	

	/**

	* Applies the current XML schema to the database (post execution).

	*

	* Call this method to apply the current schema (generally created by calling 

	* ParseSchema() or ParseSchemaString() ) to the database (creating the tables, indexes, 

	* and executing other SQL specified in the schema) after parsing.

	* @see ParseSchema(), ParseSchemaString(), ExecuteInline()

	*

	* @param array $sqlArray Array of SQL statements that will be applied rather than

	*		the current schema.

	* @param boolean $continueOnErr Continue to apply the schema even if an error occurs.

	* @returns integer 0 if failure, 1 if errors, 2 if successful.

	*/

	function ExecuteSchema( $sqlArray = NULL, $continueOnErr =  NULL ) {

		if( !is_bool( $continueOnErr ) ) {

			$continueOnErr = $this->ContinueOnError();

		}

		

		if( !isset( $sqlArray ) ) {

			$sqlArray = $this->sqlArray;

		}

		

		if( !is_array( $sqlArray ) ) {

			$this->success = 0;

		} else {

			$this->success = $this->dict->ExecuteSQLArray( $sqlArray, $continueOnErr );

		}

		

		return $this->success;

	}

	

	/**

	* Returns the current SQL array. 

	*

	* Call this method to fetch the array of SQL queries resulting from 

	* ParseSchema() or ParseSchemaString(). 

	*

	* @param string $format Format: HTML, TEXT, or NONE (PHP array)

	* @return array Array of SQL statements or FALSE if an error occurs

	*/

	function PrintSQL( $format = 'NONE' ) {

		return $this->getSQL( $format, $sqlArray );

	}

	

	/**

	* Saves the current SQL array to the local filesystem as a list of SQL queries.

	*

	* Call this method to save the array of SQL queries (generally resulting from a

	* parsed XML schema) to the filesystem.

	*

	* @param string $filename Path and name where the file should be saved.

	* @return boolean TRUE if save is successful, else FALSE. 

	*/

	function SaveSQL( $filename = './schema.sql' ) {

		

		if( !isset( $sqlArray ) ) {

			$sqlArray = $this->sqlArray;

		}

		if( !isset( $sqlArray ) ) {

			return FALSE;

		}

		

		$fp = fopen( $filename, "w" );

		

		foreach( $sqlArray as $key => $query ) {

			fwrite( $fp, $query . ";\n" );

		}

		fclose( $fp );

	}

	

	/**

	* Create an xml parser

	*

	* @return object PHP XML parser object

	*

	* @access private

	*/

	function &create_parser() {

		// Create the parser

		$xmlParser = xml_parser_create();

		xml_set_object( $xmlParser, $this );

		

		// Initialize the XML callback functions

		xml_set_element_handler( $xmlParser, '_tag_open', '_tag_close' );

		xml_set_character_data_handler( $xmlParser, '_tag_cdata' );

		

		return $xmlParser;

	}

	

	/**

	* XML Callback to process start elements

	*

	* @access private

	*/

	function _tag_open( &$parser, $tag, $attributes ) {

		switch( strtoupper( $tag ) ) {

			case 'TABLE':

				$this->obj = new dbTable( $this, $attributes );

				xml_set_object( $parser, $this->obj );

				break;

			case 'SQL':

				if( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) ) {

					$this->obj = new dbQuerySet( $this, $attributes );

					xml_set_object( $parser, $this->obj );

				}

				break;

			default:

				// print_r( array( $tag, $attributes ) );

		}

		

	}

	

	/**

	* XML Callback to process CDATA elements

	*

	* @access private

	*/

	function _tag_cdata( &$parser, $cdata ) {

	}

	

	/**

	* XML Callback to process end elements

	*

	* @access private

	* @internal

	*/

	function _tag_close( &$parser, $tag ) {

		

	}

	

	/**

	* Converts an XML schema string to the specified DTD version.

	*

	* Call this method to convert a string containing an XML schema to a different AXMLS

	* DTD version. For instance, to convert a schema created for an pre-1.0 version for 

	* AXMLS (DTD version 0.1) to a newer version of the DTD (e.g. 0.2). If no DTD version 

	* parameter is specified, the schema will be converted to the current DTD version. 

	* If the newFile parameter is provided, the converted schema will be written to the specified

	* file.

	* @see ConvertSchemaFile()

	*

	* @param string $schema String containing XML schema that will be converted.

	* @param string $newVersion DTD version to convert to.

	* @param string $newFile File name of (converted) output file.

	* @return string Converted XML schema or FALSE if an error occurs.

	*/

	function ConvertSchemaString( $schema, $newVersion = NULL, $newFile = NULL ) {

		

		// grab current version

		if( !( $version = $this->SchemaStringVersion( $schema ) ) ) {

			return FALSE;

		}

		

		if( !isset ($newVersion) ) {

			$newVersion = $this->schemaVersion;

		}

		

		if( $version == $newVersion ) {

			$result = $schema;

		} else {

			$result = $this->TransformSchema( $schema, 'convert-' . $version . '-' . $newVersion);

		}

		

		if( is_string( $result ) AND is_string( $newFile ) AND ( $fp = fopen( $newFile, 'w' ) ) ) {

			fwrite( $fp, $result );

			fclose( $fp );

		}

		

		return $result;

	}

	

	/**

	* Converts an XML schema file to the specified DTD version.

	*

	* Call this method to convert the specified XML schema file to a different AXMLS

	* DTD version. For instance, to convert a schema created for an pre-1.0 version for 

	* AXMLS (DTD version 0.1) to a newer version of the DTD (e.g. 0.2). If no DTD version 

	* parameter is specified, the schema will be converted to the current DTD version. 

	* If the newFile parameter is provided, the converted schema will be written to the specified

	* file.

	* @see ConvertSchemaString()

	*

	* @param string $filename Name of XML schema file that will be converted.

	* @param string $newVersion DTD version to convert to.

	* @param string $newFile File name of (converted) output file.

	* @return string Converted XML schema or FALSE if an error occurs.

	*/

	function ConvertSchemaFile( $filename, $newVersion = NULL, $newFile = NULL ) {

		

		// grab current version

		if( !( $version = $this->SchemaFileVersion( $filename ) ) ) {

			return FALSE;

		}

		

		if( !isset ($newVersion) ) {

			$newVersion = $this->schemaVersion;

		}

		

		if( $version == $newVersion ) {

			$result = file_get_contents( $filename );

			

			// remove unicode BOM if present

			if( substr( $result, 0, 3 ) == sprintf( '%c%c%c', 239, 187, 191 ) ) {

				$result = substr( $result, 3 );

			}

		} else {

			$result = $this->TransformSchema( $filename, 'convert-' . $version . '-' . $newVersion, 'file' );

		}

		

		if( is_string( $result ) AND is_string( $newFile ) AND ( $fp = fopen( $newFile, 'w' ) ) ) {

			fwrite( $fp, $result );

			fclose( $fp );

		}

		

		return $result;

	}

	

	function TransformSchema( $schema, $xsl, $schematype='string' )

	{

		// Fail if XSLT extension is not available

		if( ! function_exists( 'xslt_create' ) ) {

			return FALSE;

		}

		

		$xsl_file = dirname( __FILE__ ) . '/xsl/' . $xsl . '.xsl';

		

		// look for xsl

		if( !is_readable( $xsl_file ) ) {

			return FALSE;

		}

		

		switch( $schematype )

		{

			case 'file':

				if( !is_readable( $schema ) ) {

					return FALSE;

				}

				

				$schema = file_get_contents( $schema );

				break;

			case 'string':

			default:

				if( !is_string( $schema ) ) {

					return FALSE;

				}

		}

		

		$arguments = array (

			'/_xml' => $schema,

			'/_xsl' => file_get_contents( $xsl_file )

		);

		

		// create an XSLT processor

		$xh = xslt_create ();

		

		// set error handler

		xslt_set_error_handler ($xh, array (&$this, 'xslt_error_handler'));

		

		// process the schema

		$result = xslt_process ($xh, 'arg:/_xml', 'arg:/_xsl', NULL, $arguments); 

		

		xslt_free ($xh);

		

		return $result;

	}

	

	/**

	* Processes XSLT transformation errors

	*

	* @param object $parser XML parser object

	* @param integer $errno Error number

	* @param integer $level Error level

	* @param array $fields Error information fields

	*

	* @access private

	*/

	function xslt_error_handler( $parser, $errno, $level, $fields ) {

		if( is_array( $fields ) ) {

			$msg = array(

				'Message Type' => ucfirst( $fields['msgtype'] ),

				'Message Code' => $fields['code'],

				'Message' => $fields['msg'],

				'Error Number' => $errno,

				'Level' => $level

			);

			

			switch( $fields['URI'] ) {

				case 'arg:/_xml':

					$msg['Input'] = 'XML';

					break;

				case 'arg:/_xsl':

					$msg['Input'] = 'XSL';

					break;

				default:

					$msg['Input'] = $fields['URI'];

			}

			

			$msg['Line'] = $fields['line'];

		} else {

			$msg = array(

				'Message Type' => 'Error',

				'Error Number' => $errno,

				'Level' => $level,

				'Fields' => var_export( $fields, TRUE )

			);

		}

		

		$error_details = $msg['Message Type'] . ' in XSLT Transformation' . "\n"

					   . '<table>' . "\n";

		

		foreach( $msg as $label => $details ) {

			$error_details .= '<tr><td><b>' . $label . ': </b></td><td>' . htmlentities( $details ) . '</td></tr>' . "\n";

		}

		

		$error_details .= '</table>';

		

		trigger_error( $error_details, E_USER_ERROR );

	}

	

	/**

	* Returns the AXMLS Schema Version of the requested XML schema file.

	*

	* Call this method to obtain the AXMLS DTD version of the requested XML schema file.

	* @see SchemaStringVersion()

	*

	* @param string $filename AXMLS schema file

	* @return string Schema version number or FALSE on error

	*/

	function SchemaFileVersion( $filename ) {

		// Open the file

		if( !($fp = fopen( $filename, 'r' )) ) {

			// die( 'Unable to open file' );

			return FALSE;

		}

		

		// Process the file

		while( $data = fread( $fp, 4096 ) ) {

			if( preg_match( $this->versionRegex, $data, $matches ) ) {

				return !empty( $matches[2] ) ? $matches[2] : XMLS_DEFAULT_SCHEMA_VERSION;

			}

		}

		

		return FALSE;

	}

	

	/**

	* Returns the AXMLS Schema Version of the provided XML schema string.

	*

	* Call this method to obtain the AXMLS DTD version of the provided XML schema string.

	* @see SchemaFileVersion()

	*

	* @param string $xmlstring XML schema string

	* @return string Schema version number or FALSE on error

	*/

	function SchemaStringVersion( $xmlstring ) {

		if( !is_string( $xmlstring ) OR empty( $xmlstring ) ) {

			return FALSE;

		}

		

		if( preg_match( $this->versionRegex, $xmlstring, $matches ) ) {

			return !empty( $matches[2] ) ? $matches[2] : XMLS_DEFAULT_SCHEMA_VERSION;

		}

		

		return FALSE;

	}

	

	/**

	* Extracts an XML schema from an existing database.

	*

	* Call this method to create an XML schema string from an existing database.

	* If the data parameter is set to TRUE, AXMLS will include the data from the database

	* in the schema. 

	*

	* @param boolean $data Include data in schema dump

	* @return string Generated XML schema

	*/

	function ExtractSchema( $data = FALSE ) {

		$old_mode = $this->db->SetFetchMode( ADODB_FETCH_NUM );

		

		$schema = '<?xml version="1.0"?>' . "\n"

				. '<schema version="' . $this->schemaVersion . '">' . "\n";

		

		if( is_array( $tables = $this->db->MetaTables( 'TABLES' ) ) ) {

			foreach( $tables as $table ) {

				$schema .= '	<table name=…