Context Navigation

source: trunk/phpgwapi/inc/adodb/adodb-xmlschema03.inc.php @ 34

Revision 34, 61.2 KB checked in by niltonneto, 17 years ago (diff)
Versão nova do ADODB (4.5 para 4.95)
Property svn:eol-style set to `native` Property svn:executable set to ``*

Line
1	<?php
2	// Copyright (c) 2004-2005 ars Cognita Inc., all rights reserved
3	/* ******************************************************************************
4	Released under both BSD license and Lesser GPL library license.
5	Whenever there is any discrepancy between the two licenses,
6	the BSD license will take precedence.
7	*******************************************************************************/
8	/**
9	* xmlschema is a class that allows the user to quickly and easily
10	* build a database on any ADOdb-supported platform using a simple
11	* XML schema.
12	*
13	* Last Editor: $Author$
14	* @author Richard Tango-Lowy & Dan Cech
15	* @version $Revision$
16	*
17	* @package axmls
18	* @tutorial getting_started.pkg
19	*/
20
21	function _file_get_contents($file)
22	{
23	if (function_exists('file_get_contents')) return file_get_contents($file);
24
25	$f = fopen($file,'r');
26	if (!$f) return '';
27	$t = '';
28
29	while ($s = fread($f,100000)) $t .= $s;
30	fclose($f);
31	return $t;
32	}
33
34
35	/**
36	* Debug on or off
37	*/
38	if( !defined( 'XMLS_DEBUG' ) ) {
39	define( 'XMLS_DEBUG', FALSE );
40	}
41
42	/**
43	* Default prefix key
44	*/
45	if( !defined( 'XMLS_PREFIX' ) ) {
46	define( 'XMLS_PREFIX', '%%P' );
47	}
48
49	/**
50	* Maximum length allowed for object prefix
51	*/
52	if( !defined( 'XMLS_PREFIX_MAXLEN' ) ) {
53	define( 'XMLS_PREFIX_MAXLEN', 10 );
54	}
55
56	/**
57	* Execute SQL inline as it is generated
58	*/
59	if( !defined( 'XMLS_EXECUTE_INLINE' ) ) {
60	define( 'XMLS_EXECUTE_INLINE', FALSE );
61	}
62
63	/**
64	* Continue SQL Execution if an error occurs?
65	*/
66	if( !defined( 'XMLS_CONTINUE_ON_ERROR' ) ) {
67	define( 'XMLS_CONTINUE_ON_ERROR', FALSE );
68	}
69
70	/**
71	* Current Schema Version
72	*/
73	if( !defined( 'XMLS_SCHEMA_VERSION' ) ) {
74	define( 'XMLS_SCHEMA_VERSION', '0.3' );
75	}
76
77	/**
78	* Default Schema Version. Used for Schemas without an explicit version set.
79	*/
80	if( !defined( 'XMLS_DEFAULT_SCHEMA_VERSION' ) ) {
81	define( 'XMLS_DEFAULT_SCHEMA_VERSION', '0.1' );
82	}
83
84	/**
85	* How to handle data rows that already exist in a database during and upgrade.
86	* Options are INSERT (attempts to insert duplicate rows), UPDATE (updates existing
87	* rows) and IGNORE (ignores existing rows).
88	*/
89	if( !defined( 'XMLS_MODE_INSERT' ) ) {
90	define( 'XMLS_MODE_INSERT', 0 );
91	}
92	if( !defined( 'XMLS_MODE_UPDATE' ) ) {
93	define( 'XMLS_MODE_UPDATE', 1 );
94	}
95	if( !defined( 'XMLS_MODE_IGNORE' ) ) {
96	define( 'XMLS_MODE_IGNORE', 2 );
97	}
98	if( !defined( 'XMLS_EXISTING_DATA' ) ) {
99	define( 'XMLS_EXISTING_DATA', XMLS_MODE_INSERT );
100	}
101
102	/**
103	* Default Schema Version. Used for Schemas without an explicit version set.
104	*/
105	if( !defined( 'XMLS_DEFAULT_UPGRADE_METHOD' ) ) {
106	define( 'XMLS_DEFAULT_UPGRADE_METHOD', 'ALTER' );
107	}
108
109	/**
110	* Include the main ADODB library
111	*/
112	if( !defined( '_ADODB_LAYER' ) ) {
113	require( 'adodb.inc.php' );
114	require( 'adodb-datadict.inc.php' );
115	}
116
117	/**
118	* Abstract DB Object. This class provides basic methods for database objects, such
119	* as tables and indexes.
120	*
121	* @package axmls
122	* @access private
123	*/
124	class dbObject {
125
126	/**
127	* var object Parent
128	*/
129	var $parent;
130
131	/**
132	* var string current element
133	*/
134	var $currentElement;
135
136	/**
137	* NOP
138	*/
139	function dbObject( &$parent, $attributes = NULL ) {
140	$this->parent =& $parent;
141	}
142
143	/**
144	* XML Callback to process start elements
145	*
146	* @access private
147	*/
148	function _tag_open( &$parser, $tag, $attributes ) {
149
150	}
151
152	/**
153	* XML Callback to process CDATA elements
154	*
155	* @access private
156	*/
157	function _tag_cdata( &$parser, $cdata ) {
158
159	}
160
161	/**
162	* XML Callback to process end elements
163	*
164	* @access private
165	*/
166	function _tag_close( &$parser, $tag ) {
167
168	}
169
170	function create() {
171	return array();
172	}
173
174	/**
175	* Destroys the object
176	*/
177	function destroy() {
178	unset( $this );
179	}
180
181	/**
182	* Checks whether the specified RDBMS is supported by the current
183	* database object or its ranking ancestor.
184	*
185	* @param string $platform RDBMS platform name (from ADODB platform list).
186	* @return boolean TRUE if RDBMS is supported; otherwise returns FALSE.
187	*/
188	function supportedPlatform( $platform = NULL ) {
189	return is_object( $this->parent ) ? $this->parent->supportedPlatform( $platform ) : TRUE;
190	}
191
192	/**
193	* Returns the prefix set by the ranking ancestor of the database object.
194	*
195	* @param string $name Prefix string.
196	* @return string Prefix.
197	*/
198	function prefix( $name = '' ) {
199	return is_object( $this->parent ) ? $this->parent->prefix( $name ) : $name;
200	}
201
202	/**
203	* Extracts a field ID from the specified field.
204	*
205	* @param string $field Field.
206	* @return string Field ID.
207	*/
208	function FieldID( $field ) {
209	return strtoupper( preg_replace( '/^`(.+)`$/', '$1', $field ) );
210	}
211	}
212
213	/**
214	* Creates a table object in ADOdb's datadict format
215	*
216	* This class stores information about a database table. As charactaristics
217	* of the table are loaded from the external source, methods and properties
218	* of this class are used to build up the table description in ADOdb's
219	* datadict format.
220	*
221	* @package axmls
222	* @access private
223	*/
224	class dbTable extends dbObject {
225
226	/**
227	* @var string Table name
228	*/
229	var $name;
230
231	/**
232	* @var array Field specifier: Meta-information about each field
233	*/
234	var $fields = array();
235
236	/**
237	* @var array List of table indexes.
238	*/
239	var $indexes = array();
240
241	/**
242	* @var array Table options: Table-level options
243	*/
244	var $opts = array();
245
246	/**
247	* @var string Field index: Keeps track of which field is currently being processed
248	*/
249	var $current_field;
250
251	/**
252	* @var boolean Mark table for destruction
253	* @access private
254	*/
255	var $drop_table;
256
257	/**
258	* @var boolean Mark field for destruction (not yet implemented)
259	* @access private
260	*/
261	var $drop_field = array();
262
263	/**
264	* @var array Platform-specific options
265	* @access private
266	*/
267	var $currentPlatform = true;
268
269
270	/**
271	* Iniitializes a new table object.
272	*
273	* @param string $prefix DB Object prefix
274	* @param array $attributes Array of table attributes.
275	*/
276	function dbTable( &$parent, $attributes = NULL ) {
277	$this->parent =& $parent;
278	$this->name = $this->prefix($attributes['NAME']);
279	}
280
281	/**
282	* XML Callback to process start elements. Elements currently
283	* processed are: INDEX, DROP, FIELD, KEY, NOTNULL, AUTOINCREMENT & DEFAULT.
284	*
285	* @access private
286	*/
287	function _tag_open( &$parser, $tag, $attributes ) {
288	$this->currentElement = strtoupper( $tag );
289
290	switch( $this->currentElement ) {
291	case 'INDEX':
292	if( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) ) {
293	xml_set_object( $parser, $this->addIndex( $attributes ) );
294	}
295	break;
296	case 'DATA':
297	if( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) ) {
298	xml_set_object( $parser, $this->addData( $attributes ) );
299	}
300	break;
301	case 'DROP':
302	$this->drop();
303	break;
304	case 'FIELD':
305	// Add a field
306	$fieldName = $attributes['NAME'];
307	$fieldType = $attributes['TYPE'];
308	$fieldSize = isset( $attributes['SIZE'] ) ? $attributes['SIZE'] : NULL;
309	$fieldOpts = !empty( $attributes['OPTS'] ) ? $attributes['OPTS'] : NULL;
310
311	$this->addField( $fieldName, $fieldType, $fieldSize, $fieldOpts );
312	break;
313	case 'KEY':
314	case 'NOTNULL':
315	case 'AUTOINCREMENT':
316	case 'DEFDATE':
317	case 'DEFTIMESTAMP':
318	case 'UNSIGNED':
319	// Add a field option
320	$this->addFieldOpt( $this->current_field, $this->currentElement );
321	break;
322	case 'DEFAULT':
323	// Add a field option to the table object
324
325	// Work around ADOdb datadict issue that misinterprets empty strings.
326	if( $attributes['VALUE'] == '' ) {
327	$attributes['VALUE'] = " '' ";
328	}
329
330	$this->addFieldOpt( $this->current_field, $this->currentElement, $attributes['VALUE'] );
331	break;
332	case 'OPT':
333	case 'CONSTRAINT':
334	// Accept platform-specific options
335	$this->currentPlatform = ( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) );
336	break;
337	default:
338	// print_r( array( $tag, $attributes ) );
339	}
340	}
341
342	/**
343	* XML Callback to process CDATA elements
344	*
345	* @access private
346	*/
347	function _tag_cdata( &$parser, $cdata ) {
348	switch( $this->currentElement ) {
349	// Table/field constraint
350	case 'CONSTRAINT':
351	if( isset( $this->current_field ) ) {
352	$this->addFieldOpt( $this->current_field, $this->currentElement, $cdata );
353	} else {
354	$this->addTableOpt( $cdata );
355	}
356	break;
357	// Table/field option
358	case 'OPT':
359	if( isset( $this->current_field ) ) {
360	$this->addFieldOpt( $this->current_field, $cdata );
361	} else {
362	$this->addTableOpt( $cdata );
363	}
364	break;
365	default:
366
367	}
368	}
369
370	/**
371	* XML Callback to process end elements
372	*
373	* @access private
374	*/
375	function _tag_close( &$parser, $tag ) {
376	$this->currentElement = '';
377
378	switch( strtoupper( $tag ) ) {
379	case 'TABLE':
380	$this->parent->addSQL( $this->create( $this->parent ) );
381	xml_set_object( $parser, $this->parent );
382	$this->destroy();
383	break;
384	case 'FIELD':
385	unset($this->current_field);
386	break;
387	case 'OPT':
388	case 'CONSTRAINT':
389	$this->currentPlatform = true;
390	break;
391	default:
392
393	}
394	}
395
396	/**
397	* Adds an index to a table object
398	*
399	* @param array $attributes Index attributes
400	* @return object dbIndex object
401	*/
402	function &addIndex( $attributes ) {
403	$name = strtoupper( $attributes['NAME'] );
404	$this->indexes[$name] =& new dbIndex( $this, $attributes );
405	return $this->indexes[$name];
406	}
407
408	/**
409	* Adds data to a table object
410	*
411	* @param array $attributes Data attributes
412	* @return object dbData object
413	*/
414	function &addData( $attributes ) {
415	if( !isset( $this->data ) ) {
416	$this->data =& new dbData( $this, $attributes );
417	}
418	return $this->data;
419	}
420
421	/**
422	* Adds a field to a table object
423	*
424	* $name is the name of the table to which the field should be added.
425	* $type is an ADODB datadict field type. The following field types
426	* are supported as of ADODB 3.40:
427	* - C: varchar
428	* - X: CLOB (character large object) or largest varchar size
429	* if CLOB is not supported
430	* - C2: Multibyte varchar
431	* - X2: Multibyte CLOB
432	* - B: BLOB (binary large object)
433	* - D: Date (some databases do not support this, and we return a datetime type)
434	* - T: Datetime or Timestamp
435	* - L: Integer field suitable for storing booleans (0 or 1)
436	* - I: Integer (mapped to I4)
437	* - I1: 1-byte integer
438	* - I2: 2-byte integer
439	* - I4: 4-byte integer
440	* - I8: 8-byte integer
441	* - F: Floating point number
442	* - N: Numeric or decimal number
443	*
444	* @param string $name Name of the table to which the field will be added.
445	* @param string $type ADODB datadict field type.
446	* @param string $size Field size
447	* @param array $opts Field options array
448	* @return array Field specifier array
449	*/
450	function addField( $name, $type, $size = NULL, $opts = NULL ) {
451	$field_id = $this->FieldID( $name );
452
453	// Set the field index so we know where we are
454	$this->current_field = $field_id;
455
456	// Set the field name (required)
457	$this->fields[$field_id]['NAME'] = $name;
458
459	// Set the field type (required)
460	$this->fields[$field_id]['TYPE'] = $type;
461
462	// Set the field size (optional)
463	if( isset( $size ) ) {
464	$this->fields[$field_id]['SIZE'] = $size;
465	}
466
467	// Set the field options
468	if( isset( $opts ) ) {
469	$this->fields[$field_id]['OPTS'] = array($opts);
470	} else {
471	$this->fields[$field_id]['OPTS'] = array();
472	}
473	}
474
475	/**
476	* Adds a field option to the current field specifier
477	*
478	* This method adds a field option allowed by the ADOdb datadict
479	* and appends it to the given field.
480	*
481	* @param string $field Field name
482	* @param string $opt ADOdb field option
483	* @param mixed $value Field option value
484	* @return array Field specifier array
485	*/
486	function addFieldOpt( $field, $opt, $value = NULL ) {
487	if( $this->currentPlatform ) {
488	if( !isset( $value ) ) {
489	$this->fields[$this->FieldID( $field )]['OPTS'][] = $opt;
490	// Add the option and value
491	} else {
492	$this->fields[$this->FieldID( $field )]['OPTS'][] = array( $opt => $value );
493	}
494	}
495	}
496
497	/**
498	* Adds an option to the table
499	*
500	* This method takes a comma-separated list of table-level options
501	* and appends them to the table object.
502	*
503	* @param string $opt Table option
504	* @return array Options
505	*/
506	function addTableOpt( $opt ) {
507	if( $this->currentPlatform ) {
508	$this->opts[] = $opt;
509	}
510	return $this->opts;
511	}
512
513	/**
514	* Generates the SQL that will create the table in the database
515	*
516	* @param object $xmls adoSchema object
517	* @return array Array containing table creation SQL
518	*/
519	function create( &$xmls ) {
520	$sql = array();
521
522	// drop any existing indexes
523	if( is_array( $legacy_indexes = $xmls->dict->MetaIndexes( $this->name ) ) ) {
524	foreach( $legacy_indexes as $index => $index_details ) {
525	$sql[] = $xmls->dict->DropIndexSQL( $index, $this->name );
526	}
527	}
528
529	// remove fields to be dropped from table object
530	foreach( $this->drop_field as $field ) {
531	unset( $this->fields[$field] );
532	}
533
534	// if table exists
535	if( is_array( $legacy_fields = $xmls->dict->MetaColumns( $this->name ) ) ) {
536	// drop table
537	if( $this->drop_table ) {
538	$sql[] = $xmls->dict->DropTableSQL( $this->name );
539
540	return $sql;
541	}
542
543	// drop any existing fields not in schema
544	foreach( $legacy_fields as $field_id => $field ) {
545	if( !isset( $this->fields[$field_id] ) ) {
546	$sql[] = $xmls->dict->DropColumnSQL( $this->name, $field->name );
547	}
548	}
549	// if table doesn't exist
550	} else {
551	if( $this->drop_table ) {
552	return $sql;
553	}
554
555	$legacy_fields = array();
556	}
557
558	// Loop through the field specifier array, building the associative array for the field options
559	$fldarray = array();
560
561	foreach( $this->fields as $field_id => $finfo ) {
562	// Set an empty size if it isn't supplied
563	if( !isset( $finfo['SIZE'] ) ) {
564	$finfo['SIZE'] = '';
565	}
566
567	// Initialize the field array with the type and size
568	$fldarray[$field_id] = array(
569	'NAME' => $finfo['NAME'],
570	'TYPE' => $finfo['TYPE'],
571	'SIZE' => $finfo['SIZE']
572	);
573
574	// Loop through the options array and add the field options.
575	if( isset( $finfo['OPTS'] ) ) {
576	foreach( $finfo['OPTS'] as $opt ) {
577	// Option has an argument.
578	if( is_array( $opt ) ) {
579	$key = key( $opt );
580	$value = $opt[key( $opt )];
581	@$fldarray[$field_id][$key] .= $value;
582	// Option doesn't have arguments
583	} else {
584	$fldarray[$field_id][$opt] = $opt;
585	}
586	}
587	}
588	}
589
590	if( empty( $legacy_fields ) ) {
591	// Create the new table
592	$sql[] = $xmls->dict->CreateTableSQL( $this->name, $fldarray, $this->opts );
593	logMsg( end( $sql ), 'Generated CreateTableSQL' );
594	} else {
595	// Upgrade an existing table
596	logMsg( "Upgrading {$this->name} using '{$xmls->upgrade}'" );
597	switch( $xmls->upgrade ) {
598	// Use ChangeTableSQL
599	case 'ALTER':
600	logMsg( 'Generated ChangeTableSQL (ALTERing table)' );
601	$sql[] = $xmls->dict->ChangeTableSQL( $this->name, $fldarray, $this->opts );
602	break;
603	case 'REPLACE':
604	logMsg( 'Doing upgrade REPLACE (testing)' );
605	$sql[] = $xmls->dict->DropTableSQL( $this->name );
606	$sql[] = $xmls->dict->CreateTableSQL( $this->name, $fldarray, $this->opts );
607	break;
608	// ignore table
609	default:
610	return array();
611	}
612	}
613
614	foreach( $this->indexes as $index ) {
615	$sql[] = $index->create( $xmls );
616	}
617
618	if( isset( $this->data ) ) {
619	$sql[] = $this->data->create( $xmls );
620	}
621
622	return $sql;
623	}
624
625	/**
626	* Marks a field or table for destruction
627	*/
628	function drop() {
629	if( isset( $this->current_field ) ) {
630	// Drop the current field
631	logMsg( "Dropping field '{$this->current_field}' from table '{$this->name}'" );
632	// $this->drop_field[$this->current_field] = $xmls->dict->DropColumnSQL( $this->name, $this->current_field );
633	$this->drop_field[$this->current_field] = $this->current_field;
634	} else {
635	// Drop the current table
636	logMsg( "Dropping table '{$this->name}'" );
637	// $this->drop_table = $xmls->dict->DropTableSQL( $this->name );
638	$this->drop_table = TRUE;
639	}
640	}
641	}
642
643	/**
644	* Creates an index object in ADOdb's datadict format
645	*
646	* This class stores information about a database index. As charactaristics
647	* of the index are loaded from the external source, methods and properties
648	* of this class are used to build up the index description in ADOdb's
649	* datadict format.
650	*
651	* @package axmls
652	* @access private
653	*/
654	class dbIndex extends dbObject {
655
656	/**
657	* @var string Index name
658	*/
659	var $name;
660
661	/**
662	* @var array Index options: Index-level options
663	*/
664	var $opts = array();
665
666	/**
667	* @var array Indexed fields: Table columns included in this index
668	*/
669	var $columns = array();
670
671	/**
672	* @var boolean Mark index for destruction
673	* @access private
674	*/
675	var $drop = FALSE;
676
677	/**
678	* Initializes the new dbIndex object.
679	*
680	* @param object $parent Parent object
681	* @param array $attributes Attributes
682	*
683	* @internal
684	*/
685	function dbIndex( &$parent, $attributes = NULL ) {
686	$this->parent =& $parent;
687
688	$this->name = $this->prefix ($attributes['NAME']);
689	}
690
691	/**
692	* XML Callback to process start elements
693	*
694	* Processes XML opening tags.
695	* Elements currently processed are: DROP, CLUSTERED, BITMAP, UNIQUE, FULLTEXT & HASH.
696	*
697	* @access private
698	*/
699	function _tag_open( &$parser, $tag, $attributes ) {
700	$this->currentElement = strtoupper( $tag );
701
702	switch( $this->currentElement ) {
703	case 'DROP':
704	$this->drop();
705	break;
706	case 'CLUSTERED':
707	case 'BITMAP':
708	case 'UNIQUE':
709	case 'FULLTEXT':
710	case 'HASH':
711	// Add index Option
712	$this->addIndexOpt( $this->currentElement );
713	break;
714	default:
715	// print_r( array( $tag, $attributes ) );
716	}
717	}
718
719	/**
720	* XML Callback to process CDATA elements
721	*
722	* Processes XML cdata.
723	*
724	* @access private
725	*/
726	function _tag_cdata( &$parser, $cdata ) {
727	switch( $this->currentElement ) {
728	// Index field name
729	case 'COL':
730	$this->addField( $cdata );
731	break;
732	default:
733
734	}
735	}
736
737	/**
738	* XML Callback to process end elements
739	*
740	* @access private
741	*/
742	function _tag_close( &$parser, $tag ) {
743	$this->currentElement = '';
744
745	switch( strtoupper( $tag ) ) {
746	case 'INDEX':
747	xml_set_object( $parser, $this->parent );
748	break;
749	}
750	}
751
752	/**
753	* Adds a field to the index
754	*
755	* @param string $name Field name
756	* @return string Field list
757	*/
758	function addField( $name ) {
759	$this->columns[$this->FieldID( $name )] = $name;
760
761	// Return the field list
762	return $this->columns;
763	}
764
765	/**
766	* Adds options to the index
767	*
768	* @param string $opt Comma-separated list of index options.
769	* @return string Option list
770	*/
771	function addIndexOpt( $opt ) {
772	$this->opts[] = $opt;
773
774	// Return the options list
775	return $this->opts;
776	}
777
778	/**
779	* Generates the SQL that will create the index in the database
780	*
781	* @param object $xmls adoSchema object
782	* @return array Array containing index creation SQL
783	*/
784	function create( &$xmls ) {
785	if( $this->drop ) {
786	return NULL;
787	}
788
789	// eliminate any columns that aren't in the table
790	foreach( $this->columns as $id => $col ) {
791	if( !isset( $this->parent->fields[$id] ) ) {
792	unset( $this->columns[$id] );
793	}
794	}
795
796	return $xmls->dict->CreateIndexSQL( $this->name, $this->parent->name, $this->columns, $this->opts );
797	}
798
799	/**
800	* Marks an index for destruction
801	*/
802	function drop() {
803	$this->drop = TRUE;
804	}
805	}
806
807	/**
808	* Creates a data object in ADOdb's datadict format
809	*
810	* This class stores information about table data, and is called
811	* when we need to load field data into a table.
812	*
813	* @package axmls
814	* @access private
815	*/
816	class dbData extends dbObject {
817
818	var $data = array();
819
820	var $row;
821
822	/**
823	* Initializes the new dbData object.
824	*
825	* @param object $parent Parent object
826	* @param array $attributes Attributes
827	*
828	* @internal
829	*/
830	function dbData( &$parent, $attributes = NULL ) {
831	$this->parent =& $parent;
832	}
833
834	/**
835	* XML Callback to process start elements
836	*
837	* Processes XML opening tags.
838	* Elements currently processed are: ROW and F (field).
839	*
840	* @access private
841	*/
842	function _tag_open( &$parser, $tag, $attributes ) {
843	$this->currentElement = strtoupper( $tag );
844
845	switch( $this->currentElement ) {
846	case 'ROW':
847	$this->row = count( $this->data );
848	$this->data[$this->row] = array();
849	break;
850	case 'F':
851	$this->addField($attributes);
852	default:
853	// print_r( array( $tag, $attributes ) );
854	}
855	}
856
857	/**
858	* XML Callback to process CDATA elements
859	*
860	* Processes XML cdata.
861	*
862	* @access private
863	*/
864	function _tag_cdata( &$parser, $cdata ) {
865	switch( $this->currentElement ) {
866	// Index field name
867	case 'F':
868	$this->addData( $cdata );
869	break;
870	default:
871
872	}
873	}
874
875	/**
876	* XML Callback to process end elements
877	*
878	* @access private
879	*/
880	function _tag_close( &$parser, $tag ) {
881	$this->currentElement = '';
882
883	switch( strtoupper( $tag ) ) {
884	case 'DATA':
885	xml_set_object( $parser, $this->parent );
886	break;
887	}
888	}
889
890	/**
891	* Adds a field to the insert
892	*
893	* @param string $name Field name
894	* @return string Field list
895	*/
896	function addField( $attributes ) {
897	// check we're in a valid row
898	if( !isset( $this->row ) \|\| !isset( $this->data[$this->row] ) ) {
899	return;
900	}
901
902	// Set the field index so we know where we are
903	if( isset( $attributes['NAME'] ) ) {
904	$this->current_field = $this->FieldID( $attributes['NAME'] );
905	} else {
906	$this->current_field = count( $this->data[$this->row] );
907	}
908
909	// initialise data
910	if( !isset( $this->data[$this->row][$this->current_field] ) ) {
911	$this->data[$this->row][$this->current_field] = '';
912	}
913	}
914
915	/**
916	* Adds options to the index
917	*
918	* @param string $opt Comma-separated list of index options.
919	* @return string Option list
920	*/
921	function addData( $cdata ) {
922	// check we're in a valid field
923	if ( isset( $this->data[$this->row][$this->current_field] ) ) {
924	// add data to field
925	$this->data[$this->row][$this->current_field] .= $cdata;
926	}
927	}
928
929	/**
930	* Generates the SQL that will add/update the data in the database
931	*
932	* @param object $xmls adoSchema object
933	* @return array Array containing index creation SQL
934	*/
935	function create( &$xmls ) {
936	$table = $xmls->dict->TableName($this->parent->name);
937	$table_field_count = count($this->parent->fields);
938	$tables = $xmls->db->MetaTables();
939	$sql = array();
940
941	$ukeys = $xmls->db->MetaPrimaryKeys( $table );
942	if( !empty( $this->parent->indexes ) and !empty( $ukeys ) ) {
943	foreach( $this->parent->indexes as $indexObj ) {
944	if( !in_array( $indexObj->name, $ukeys ) ) $ukeys[] = $indexObj->name;
945	}
946	}
947
948	// eliminate any columns that aren't in the table
949	foreach( $this->data as $row ) {
950	$table_fields = $this->parent->fields;
951	$fields = array();
952	$rawfields = array(); // Need to keep some of the unprocessed data on hand.
953
954	foreach( $row as $field_id => $field_data ) {
955	if( !array_key_exists( $field_id, $table_fields ) ) {
956	if( is_numeric( $field_id ) ) {
957	$field_id = reset( array_keys( $table_fields ) );
958	} else {
959	continue;
960	}
961	}
962
963	$name = $table_fields[$field_id]['NAME'];
964
965	switch( $table_fields[$field_id]['TYPE'] ) {
966	case 'I':
967	case 'I1':
968	case 'I2':
969	case 'I4':
970	case 'I8':
971	$fields[$name] = intval($field_data);
972	break;
973	case 'C':
974	case 'C2':
975	case 'X':
976	case 'X2':
977	default:
978	$fields[$name] = $xmls->db->qstr( $field_data );
979	$rawfields[$name] = $field_data;
980	}
981
982	unset($table_fields[$field_id]);
983
984	}
985
986	// check that at least 1 column is specified
987	if( empty( $fields ) ) {
988	continue;
989	}
990
991	// check that no required columns are missing
992	if( count( $fields ) < $table_field_count ) {
993	foreach( $table_fields as $field ) {
994	if( isset( $field['OPTS'] ) and ( in_array( 'NOTNULL', $field['OPTS'] ) \|\| in_array( 'KEY', $field['OPTS'] ) ) && !in_array( 'AUTOINCREMENT', $field['OPTS'] ) ) {
995	continue(2);
996	}
997	}
998	}
999
1000	// The rest of this method deals with updating existing data records.
1001
1002	if( !in_array( $table, $tables ) or ( $mode = $xmls->existingData() ) == XMLS_MODE_INSERT ) {
1003	// Table doesn't yet exist, so it's safe to insert.
1004	logMsg( "$table doesn't exist, inserting or mode is INSERT" );
1005	$sql[] = 'INSERT INTO '. $table .' ('. implode( ',', array_keys( $fields ) ) .') VALUES ('. implode( ',', $fields ) .')';
1006	continue;
1007	}
1008
1009	// Prepare to test for potential violations. Get primary keys and unique indexes
1010	$mfields = array_merge( $fields, $rawfields );
1011	$keyFields = array_intersect( $ukeys, array_keys( $mfields ) );
1012
1013	if( empty( $ukeys ) or count( $keyFields ) == 0 ) {
1014	// No unique keys in schema, so safe to insert
1015	logMsg( "Either schema or data has no unique keys, so safe to insert" );
1016	$sql[] = 'INSERT INTO '. $table .' ('. implode( ',', array_keys( $fields ) ) .') VALUES ('. implode( ',', $fields ) .')';
1017	continue;
1018	}
1019
1020	// Select record containing matching unique keys.
1021	$where = '';
1022	foreach( $ukeys as $key ) {
1023	if( isset( $mfields[$key] ) and $mfields[$key] ) {
1024	if( $where ) $where .= ' AND ';
1025	$where .= $key . ' = ' . $xmls->db->qstr( $mfields[$key] );
1026	}
1027	}
1028	$records = $xmls->db->Execute( 'SELECT * FROM ' . $table . ' WHERE ' . $where );
1029	switch( $records->RecordCount() ) {
1030	case 0:
1031	// No matching record, so safe to insert.
1032	logMsg( "No matching records. Inserting new row with unique data" );
1033	$sql[] = $xmls->db->GetInsertSQL( $records, $mfields );
1034	break;
1035	case 1:
1036	// Exactly one matching record, so we can update if the mode permits.
1037	logMsg( "One matching record..." );
1038	if( $mode == XMLS_MODE_UPDATE ) {
1039	logMsg( "...Updating existing row from unique data" );
1040	$sql[] = $xmls->db->GetUpdateSQL( $records, $mfields );
1041	}
1042	break;
1043	default:
1044	// More than one matching record; the result is ambiguous, so we must ignore the row.
1045	logMsg( "More than one matching record. Ignoring row." );
1046	}
1047	}
1048	return $sql;
1049	}
1050	}
1051
1052	/**
1053	* Creates the SQL to execute a list of provided SQL queries
1054	*
1055	* @package axmls
1056	* @access private
1057	*/
1058	class dbQuerySet extends dbObject {
1059
1060	/**
1061	* @var array List of SQL queries
1062	*/
1063	var $queries = array();
1064
1065	/**
1066	* @var string String used to build of a query line by line
1067	*/
1068	var $query;
1069
1070	/**
1071	* @var string Query prefix key
1072	*/
1073	var $prefixKey = '';
1074
1075	/**
1076	* @var boolean Auto prefix enable (TRUE)
1077	*/
1078	var $prefixMethod = 'AUTO';
1079
1080	/**
1081	* Initializes the query set.
1082	*
1083	* @param object $parent Parent object
1084	* @param array $attributes Attributes
1085	*/
1086	function dbQuerySet( &$parent, $attributes = NULL ) {
1087	$this->parent =& $parent;
1088
1089	// Overrides the manual prefix key
1090	if( isset( $attributes['KEY'] ) ) {
1091	$this->prefixKey = $attributes['KEY'];
1092	}
1093
1094	$prefixMethod = isset( $attributes['PREFIXMETHOD'] ) ? strtoupper( trim( $attributes['PREFIXMETHOD'] ) ) : '';
1095
1096	// Enables or disables automatic prefix prepending
1097	switch( $prefixMethod ) {
1098	case 'AUTO':
1099	$this->prefixMethod = 'AUTO';
1100	break;
1101	case 'MANUAL':
1102	$this->prefixMethod = 'MANUAL';
1103	break;
1104	case 'NONE':
1105	$this->prefixMethod = 'NONE';
1106	break;
1107	}
1108	}
1109
1110	/**
1111	* XML Callback to process start elements. Elements currently
1112	* processed are: QUERY.
1113	*
1114	* @access private
1115	*/
1116	function _tag_open( &$parser, $tag, $attributes ) {
1117	$this->currentElement = strtoupper( $tag );
1118
1119	switch( $this->currentElement ) {
1120	case 'QUERY':
1121	// Create a new query in a SQL queryset.
1122	// Ignore this query set if a platform is specified and it's different than the
1123	// current connection platform.
1124	if( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) ) {
1125	$this->newQuery();
1126	} else {
1127	$this->discardQuery();
1128	}
1129	break;
1130	default:
1131	// print_r( array( $tag, $attributes ) );
1132	}
1133	}
1134
1135	/**
1136	* XML Callback to process CDATA elements
1137	*/
1138	function _tag_cdata( &$parser, $cdata ) {
1139	switch( $this->currentElement ) {
1140	// Line of queryset SQL data
1141	case 'QUERY':
1142	$this->buildQuery( $cdata );
1143	break;
1144	default:
1145
1146	}
1147	}
1148
1149	/**
1150	* XML Callback to process end elements
1151	*
1152	* @access private
1153	*/
1154	function _tag_close( &$parser, $tag ) {
1155	$this->currentElement = '';
1156
1157	switch( strtoupper( $tag ) ) {
1158	case 'QUERY':
1159	// Add the finished query to the open query set.
1160	$this->addQuery();
1161	break;
1162	case 'SQL':
1163	$this->parent->addSQL( $this->create( $this->parent ) );
1164	xml_set_object( $parser, $this->parent );
1165	$this->destroy();
1166	break;
1167	default:
1168
1169	}
1170	}
1171
1172	/**
1173	* Re-initializes the query.
1174	*
1175	* @return boolean TRUE
1176	*/
1177	function newQuery() {
1178	$this->query = '';
1179
1180	return TRUE;
1181	}
1182
1183	/**
1184	* Discards the existing query.
1185	*
1186	* @return boolean TRUE
1187	*/
1188	function discardQuery() {
1189	unset( $this->query );
1190
1191	return TRUE;
1192	}
1193
1194	/**
1195	* Appends a line to a query that is being built line by line
1196	*
1197	* @param string $data Line of SQL data or NULL to initialize a new query
1198	* @return string SQL query string.
1199	*/
1200	function buildQuery( $sql = NULL ) {
1201	if( !isset( $this->query ) OR empty( $sql ) ) {
1202	return FALSE;
1203	}
1204
1205	$this->query .= $sql;
1206
1207	return $this->query;
1208	}
1209
1210	/**
1211	* Adds a completed query to the query list
1212	*
1213	* @return string SQL of added query
1214	*/
1215	function addQuery() {
1216	if( !isset( $this->query ) ) {
1217	return FALSE;
1218	}
1219
1220	$this->queries[] = $return = trim($this->query);
1221
1222	unset( $this->query );
1223
1224	return $return;
1225	}
1226
1227	/**
1228	* Creates and returns the current query set
1229	*
1230	* @param object $xmls adoSchema object
1231	* @return array Query set
1232	*/
1233	function create( &$xmls ) {
1234	foreach( $this->queries as $id => $query ) {
1235	switch( $this->prefixMethod ) {
1236	case 'AUTO':
1237	// Enable auto prefix replacement
1238
1239	// Process object prefix.
1240	// Evaluate SQL statements to prepend prefix to objects
1241	$query = $this->prefixQuery( '/^\s((?is)INSERT\s+(INTO\s+)?)((\w+\s,?\s)+)(\s.$)/', $query, $xmls->objectPrefix );
1242	$query = $this->prefixQuery( '/^\s((?is)UPDATE\s+(FROM\s+)?)((\w+\s,?\s)+)(\s.$)/', $query, $xmls->objectPrefix );
1243	$query = $this->prefixQuery( '/^\s((?is)DELETE\s+(FROM\s+)?)((\w+\s,?\s)+)(\s.$)/', $query, $xmls->objectPrefix );
1244
1245	// SELECT statements aren't working yet
1246	#$data = preg_replace( '/(?ias)(^\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$
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: