Context Navigation

adodb-xmlschema.inc.php @ 18609

Visit:

Revision 18609, 54.0 KB checked in by kajiwara, 16 years ago (diff)
正式版にナイトリービルド版をマージしてみるテスト

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

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

Context Navigation

source: tmp/version-2_5-test/data/module/adodb/adodb-xmlschema.inc.php @ 18609

Download in other formats: