Context Navigation

source: Dev/trunk/rdfapi/util/adodb/adodb-xmlschema03.inc.php @ 12

Last change on this file since 12 was 12, checked in by basvannuland, 14 years ago
Added RAP RDF API Added RDF reader writer for save and load survey
File size: 63.5 KB

Rev	Line
[12]	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: cweiske $
	14	* @author Richard Tango-Lowy & Dan Cech
	15	* @version $Revision: 351 $
	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)(^\sSELECT\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: 351 $
	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	?>

Note: See TracBrowser for help on using the repository browser.

Download in other formats: