3ed5aecbe07ff5d77eb071c159a48579e42b79f3
[Packages/TYPO3.CMS.git] / typo3 / sysext / adodb / adodb / adodb-xmlschema03.inc.php
1 <?php
2 // Copyright (c) 2004-2005 ars Cognita Inc., all rights reserved
3 /* ******************************************************************************
4 Released under both BSD license and Lesser GPL library license.
5 Whenever there is any discrepancy between the two licenses,
6 the BSD license will take precedence.
7 *******************************************************************************/
8 /**
9 * xmlschema is a class that allows the user to quickly and easily
10 * build a database on any ADOdb-supported platform using a simple
11 * XML schema.
12 *
13 * Last Editor: $Author: jlim $
14 * @author Richard Tango-Lowy & Dan Cech
15 * @version $Revision: 1.62 $
16 *
17 * @package axmls
18 * @tutorial getting_started.pkg
19 */
20
21 function _file_get_contents($file)
22 {
23 if (function_exists('file_get_contents')) return file_get_contents($file);
24
25 $f = fopen($file,'r');
26 if (!$f) return '';
27 $t = '';
28
29 while ($s = fread($f,100000)) $t .= $s;
30 fclose($f);
31 return $t;
32 }
33
34
35 /**
36 * Debug on or off
37 */
38 if( !defined( 'XMLS_DEBUG' ) ) {
39 define( 'XMLS_DEBUG', FALSE );
40 }
41
42 /**
43 * Default prefix key
44 */
45 if( !defined( 'XMLS_PREFIX' ) ) {
46 define( 'XMLS_PREFIX', '%%P' );
47 }
48
49 /**
50 * Maximum length allowed for object prefix
51 */
52 if( !defined( 'XMLS_PREFIX_MAXLEN' ) ) {
53 define( 'XMLS_PREFIX_MAXLEN', 10 );
54 }
55
56 /**
57 * Execute SQL inline as it is generated
58 */
59 if( !defined( 'XMLS_EXECUTE_INLINE' ) ) {
60 define( 'XMLS_EXECUTE_INLINE', FALSE );
61 }
62
63 /**
64 * Continue SQL Execution if an error occurs?
65 */
66 if( !defined( 'XMLS_CONTINUE_ON_ERROR' ) ) {
67 define( 'XMLS_CONTINUE_ON_ERROR', FALSE );
68 }
69
70 /**
71 * Current Schema Version
72 */
73 if( !defined( 'XMLS_SCHEMA_VERSION' ) ) {
74 define( 'XMLS_SCHEMA_VERSION', '0.3' );
75 }
76
77 /**
78 * Default Schema Version. Used for Schemas without an explicit version set.
79 */
80 if( !defined( 'XMLS_DEFAULT_SCHEMA_VERSION' ) ) {
81 define( 'XMLS_DEFAULT_SCHEMA_VERSION', '0.1' );
82 }
83
84 /**
85 * How to handle data rows that already exist in a database during and upgrade.
86 * Options are INSERT (attempts to insert duplicate rows), UPDATE (updates existing
87 * rows) and IGNORE (ignores existing rows).
88 */
89 if( !defined( 'XMLS_MODE_INSERT' ) ) {
90 define( 'XMLS_MODE_INSERT', 0 );
91 }
92 if( !defined( 'XMLS_MODE_UPDATE' ) ) {
93 define( 'XMLS_MODE_UPDATE', 1 );
94 }
95 if( !defined( 'XMLS_MODE_IGNORE' ) ) {
96 define( 'XMLS_MODE_IGNORE', 2 );
97 }
98 if( !defined( 'XMLS_EXISTING_DATA' ) ) {
99 define( 'XMLS_EXISTING_DATA', XMLS_MODE_INSERT );
100 }
101
102 /**
103 * Default Schema Version. Used for Schemas without an explicit version set.
104 */
105 if( !defined( 'XMLS_DEFAULT_UPGRADE_METHOD' ) ) {
106 define( 'XMLS_DEFAULT_UPGRADE_METHOD', 'ALTER' );
107 }
108
109 /**
110 * Include the main ADODB library
111 */
112 if( !defined( '_ADODB_LAYER' ) ) {
113 require( 'adodb.inc.php' );
114 require( 'adodb-datadict.inc.php' );
115 }
116
117 /**
118 * Abstract DB Object. This class provides basic methods for database objects, such
119 * as tables and indexes.
120 *
121 * @package axmls
122 * @access private
123 */
124 class dbObject {
125
126 /**
127 * var object Parent
128 */
129 var $parent;
130
131 /**
132 * var string current element
133 */
134 var $currentElement;
135
136 /**
137 * NOP
138 */
139 function dbObject( &$parent, $attributes = NULL ) {
140 $this->parent = $parent;
141 }
142
143 /**
144 * XML Callback to process start elements
145 *
146 * @access private
147 */
148 function _tag_open( &$parser, $tag, $attributes ) {
149
150 }
151
152 /**
153 * XML Callback to process CDATA elements
154 *
155 * @access private
156 */
157 function _tag_cdata( &$parser, $cdata ) {
158
159 }
160
161 /**
162 * XML Callback to process end elements
163 *
164 * @access private
165 */
166 function _tag_close( &$parser, $tag ) {
167
168 }
169
170 function create(&$xmls) {
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(isset($this->currentPlatform)) {
508 $this->opts[$this->parent->db->databaseType] = $opt;
509 }
510 return $this->opts;
511 }
512
513
514 /**
515 * Generates the SQL that will create the table in the database
516 *
517 * @param object $xmls adoSchema object
518 * @return array Array containing table creation SQL
519 */
520 function create( &$xmls ) {
521 $sql = array();
522
523 // drop any existing indexes
524 if( is_array( $legacy_indexes = $xmls->dict->MetaIndexes( $this->name ) ) ) {
525 foreach( $legacy_indexes as $index => $index_details ) {
526 $sql[] = $xmls->dict->DropIndexSQL( $index, $this->name );
527 }
528 }
529
530 // remove fields to be dropped from table object
531 foreach( $this->drop_field as $field ) {
532 unset( $this->fields[$field] );
533 }
534
535 // if table exists
536 if( is_array( $legacy_fields = $xmls->dict->MetaColumns( $this->name ) ) ) {
537 // drop table
538 if( $this->drop_table ) {
539 $sql[] = $xmls->dict->DropTableSQL( $this->name );
540
541 return $sql;
542 }
543
544 // drop any existing fields not in schema
545 foreach( $legacy_fields as $field_id => $field ) {
546 if( !isset( $this->fields[$field_id] ) ) {
547 $sql[] = $xmls->dict->DropColumnSQL( $this->name, $field->name );
548 }
549 }
550 // if table doesn't exist
551 } else {
552 if( $this->drop_table ) {
553 return $sql;
554 }
555
556 $legacy_fields = array();
557 }
558
559 // Loop through the field specifier array, building the associative array for the field options
560 $fldarray = array();
561
562 foreach( $this->fields as $field_id => $finfo ) {
563 // Set an empty size if it isn't supplied
564 if( !isset( $finfo['SIZE'] ) ) {
565 $finfo['SIZE'] = '';
566 }
567
568 // Initialize the field array with the type and size
569 $fldarray[$field_id] = array(
570 'NAME' => $finfo['NAME'],
571 'TYPE' => $finfo['TYPE'],
572 'SIZE' => $finfo['SIZE']
573 );
574
575 // Loop through the options array and add the field options.
576 if( isset( $finfo['OPTS'] ) ) {
577 foreach( $finfo['OPTS'] as $opt ) {
578 // Option has an argument.
579 if( is_array( $opt ) ) {
580 $key = key( $opt );
581 $value = $opt[key( $opt )];
582 @$fldarray[$field_id][$key] .= $value;
583 // Option doesn't have arguments
584 } else {
585 $fldarray[$field_id][$opt] = $opt;
586 }
587 }
588 }
589 }
590
591 if( empty( $legacy_fields ) ) {
592 // Create the new table
593 $sql[] = $xmls->dict->CreateTableSQL( $this->name, $fldarray, $this->opts );
594 logMsg( end( $sql ), 'Generated CreateTableSQL' );
595 } else {
596 // Upgrade an existing table
597 logMsg( "Upgrading {$this->name} using '{$xmls->upgrade}'" );
598 switch( $xmls->upgrade ) {
599 // Use ChangeTableSQL
600 case 'ALTER':
601 logMsg( 'Generated ChangeTableSQL (ALTERing table)' );
602 $sql[] = $xmls->dict->ChangeTableSQL( $this->name, $fldarray, $this->opts );
603 break;
604 case 'REPLACE':
605 logMsg( 'Doing upgrade REPLACE (testing)' );
606 $sql[] = $xmls->dict->DropTableSQL( $this->name );
607 $sql[] = $xmls->dict->CreateTableSQL( $this->name, $fldarray, $this->opts );
608 break;
609 // ignore table
610 default:
611 return array();
612 }
613 }
614
615 foreach( $this->indexes as $index ) {
616 $sql[] = $index->create( $xmls );
617 }
618
619 if( isset( $this->data ) ) {
620 $sql[] = $this->data->create( $xmls );
621 }
622
623 return $sql;
624 }
625
626 /**
627 * Marks a field or table for destruction
628 */
629 function drop() {
630 if( isset( $this->current_field ) ) {
631 // Drop the current field
632 logMsg( "Dropping field '{$this->current_field}' from table '{$this->name}'" );
633 // $this->drop_field[$this->current_field] = $xmls->dict->DropColumnSQL( $this->name, $this->current_field );
634 $this->drop_field[$this->current_field] = $this->current_field;
635 } else {
636 // Drop the current table
637 logMsg( "Dropping table '{$this->name}'" );
638 // $this->drop_table = $xmls->dict->DropTableSQL( $this->name );
639 $this->drop_table = TRUE;
640 }
641 }
642 }
643
644 /**
645 * Creates an index object in ADOdb's datadict format
646 *
647 * This class stores information about a database index. As charactaristics
648 * of the index are loaded from the external source, methods and properties
649 * of this class are used to build up the index description in ADOdb's
650 * datadict format.
651 *
652 * @package axmls
653 * @access private
654 */
655 class dbIndex extends dbObject {
656
657 /**
658 * @var string Index name
659 */
660 var $name;
661
662 /**
663 * @var array Index options: Index-level options
664 */
665 var $opts = array();
666
667 /**
668 * @var array Indexed fields: Table columns included in this index
669 */
670 var $columns = array();
671
672 /**
673 * @var boolean Mark index for destruction
674 * @access private
675 */
676 var $drop = FALSE;
677
678 /**
679 * Initializes the new dbIndex object.
680 *
681 * @param object $parent Parent object
682 * @param array $attributes Attributes
683 *
684 * @internal
685 */
686 function dbIndex( &$parent, $attributes = NULL ) {
687 $this->parent = $parent;
688
689 $this->name = $this->prefix ($attributes['NAME']);
690 }
691
692 /**
693 * XML Callback to process start elements
694 *
695 * Processes XML opening tags.
696 * Elements currently processed are: DROP, CLUSTERED, BITMAP, UNIQUE, FULLTEXT & HASH.
697 *
698 * @access private
699 */
700 function _tag_open( &$parser, $tag, $attributes ) {
701 $this->currentElement = strtoupper( $tag );
702
703 switch( $this->currentElement ) {
704 case 'DROP':
705 $this->drop();
706 break;
707 case 'CLUSTERED':
708 case 'BITMAP':
709 case 'UNIQUE':
710 case 'FULLTEXT':
711 case 'HASH':
712 // Add index Option
713 $this->addIndexOpt( $this->currentElement );
714 break;
715 default:
716 // print_r( array( $tag, $attributes ) );
717 }
718 }
719
720 /**
721 * XML Callback to process CDATA elements
722 *
723 * Processes XML cdata.
724 *
725 * @access private
726 */
727 function _tag_cdata( &$parser, $cdata ) {
728 switch( $this->currentElement ) {
729 // Index field name
730 case 'COL':
731 $this->addField( $cdata );
732 break;
733 default:
734
735 }
736 }
737
738 /**
739 * XML Callback to process end elements
740 *
741 * @access private
742 */
743 function _tag_close( &$parser, $tag ) {
744 $this->currentElement = '';
745
746 switch( strtoupper( $tag ) ) {
747 case 'INDEX':
748 xml_set_object( $parser, $this->parent );
749 break;
750 }
751 }
752
753 /**
754 * Adds a field to the index
755 *
756 * @param string $name Field name
757 * @return string Field list
758 */
759 function addField( $name ) {
760 $this->columns[$this->FieldID( $name )] = $name;
761
762 // Return the field list
763 return $this->columns;
764 }
765
766 /**
767 * Adds options to the index
768 *
769 * @param string $opt Comma-separated list of index options.
770 * @return string Option list
771 */
772 function addIndexOpt( $opt ) {
773 $this->opts[] = $opt;
774
775 // Return the options list
776 return $this->opts;
777 }
778
779 /**
780 * Generates the SQL that will create the index in the database
781 *
782 * @param object $xmls adoSchema object
783 * @return array Array containing index creation SQL
784 */
785 function create( &$xmls ) {
786 if( $this->drop ) {
787 return NULL;
788 }
789
790 // eliminate any columns that aren't in the table
791 foreach( $this->columns as $id => $col ) {
792 if( !isset( $this->parent->fields[$id] ) ) {
793 unset( $this->columns[$id] );
794 }
795 }
796
797 return $xmls->dict->CreateIndexSQL( $this->name, $this->parent->name, $this->columns, $this->opts );
798 }
799
800 /**
801 * Marks an index for destruction
802 */
803 function drop() {
804 $this->drop = TRUE;
805 }
806 }
807
808 /**
809 * Creates a data object in ADOdb's datadict format
810 *
811 * This class stores information about table data, and is called
812 * when we need to load field data into a table.
813 *
814 * @package axmls
815 * @access private
816 */
817 class dbData extends dbObject {
818
819 var $data = array();
820
821 var $row;
822
823 /**
824 * Initializes the new dbData object.
825 *
826 * @param object $parent Parent object
827 * @param array $attributes Attributes
828 *
829 * @internal
830 */
831 function dbData( &$parent, $attributes = NULL ) {
832 $this->parent = $parent;
833 }
834
835 /**
836 * XML Callback to process start elements
837 *
838 * Processes XML opening tags.
839 * Elements currently processed are: ROW and F (field).
840 *
841 * @access private
842 */
843 function _tag_open( &$parser, $tag, $attributes ) {
844 $this->currentElement = strtoupper( $tag );
845
846 switch( $this->currentElement ) {
847 case 'ROW':
848 $this->row = count( $this->data );
849 $this->data[$this->row] = array();
850 break;
851 case 'F':
852 $this->addField($attributes);
853 default:
854 // print_r( array( $tag, $attributes ) );
855 }
856 }
857
858 /**
859 * XML Callback to process CDATA elements
860 *
861 * Processes XML cdata.
862 *
863 * @access private
864 */
865 function _tag_cdata( &$parser, $cdata ) {
866 switch( $this->currentElement ) {
867 // Index field name
868 case 'F':
869 $this->addData( $cdata );
870 break;
871 default:
872
873 }
874 }
875
876 /**
877 * XML Callback to process end elements
878 *
879 * @access private
880 */
881 function _tag_close( &$parser, $tag ) {
882 $this->currentElement = '';
883
884 switch( strtoupper( $tag ) ) {
885 case 'DATA':
886 xml_set_object( $parser, $this->parent );
887 break;
888 }
889 }
890
891 /**
892 * Adds a field to the insert
893 *
894 * @param string $name Field name
895 * @return string Field list
896 */
897 function addField( $attributes ) {
898 // check we're in a valid row
899 if( !isset( $this->row ) || !isset( $this->data[$this->row] ) ) {
900 return;
901 }
902
903 // Set the field index so we know where we are
904 if( isset( $attributes['NAME'] ) ) {
905 $this->current_field = $this->FieldID( $attributes['NAME'] );
906 } else {
907 $this->current_field = count( $this->data[$this->row] );
908 }
909
910 // initialise data
911 if( !isset( $this->data[$this->row][$this->current_field] ) ) {
912 $this->data[$this->row][$this->current_field] = '';
913 }
914 }
915
916 /**
917 * Adds options to the index
918 *
919 * @param string $opt Comma-separated list of index options.
920 * @return string Option list
921 */
922 function addData( $cdata ) {
923 // check we're in a valid field
924 if ( isset( $this->data[$this->row][$this->current_field] ) ) {
925 // add data to field
926 $this->data[$this->row][$this->current_field] .= $cdata;
927 }
928 }
929
930 /**
931 * Generates the SQL that will add/update the data in the database
932 *
933 * @param object $xmls adoSchema object
934 * @return array Array containing index creation SQL
935 */
936 function create( &$xmls ) {
937 $table = $xmls->dict->TableName($this->parent->name);
938 $table_field_count = count($this->parent->fields);
939 $tables = $xmls->db->MetaTables();
940 $sql = array();
941
942 $ukeys = $xmls->db->MetaPrimaryKeys( $table );
943 if( !empty( $this->parent->indexes ) and !empty( $ukeys ) ) {
944 foreach( $this->parent->indexes as $indexObj ) {
945 if( !in_array( $indexObj->name, $ukeys ) ) $ukeys[] = $indexObj->name;
946 }
947 }
948
949 // eliminate any columns that aren't in the table
950 foreach( $this->data as $row ) {
951 $table_fields = $this->parent->fields;
952 $fields = array();
953 $rawfields = array(); // Need to keep some of the unprocessed data on hand.
954
955 foreach( $row as $field_id => $field_data ) {
956 if( !array_key_exists( $field_id, $table_fields ) ) {
957 if( is_numeric( $field_id ) ) {
958 $field_id = reset( array_keys( $table_fields ) );
959 } else {
960 continue;
961 }
962 }
963
964 $name = $table_fields[$field_id]['NAME'];
965
966 switch( $table_fields[$field_id]['TYPE'] ) {
967 case 'I':
968 case 'I1':
969 case 'I2':
970 case 'I4':
971 case 'I8':
972 $fields[$name] = intval($field_data);
973 break;
974 case 'C':
975 case 'C2':
976 case 'X':
977 case 'X2':
978 default:
979 $fields[$name] = $xmls->db->qstr( $field_data );
980 $rawfields[$name] = $field_data;
981 }
982
983 unset($table_fields[$field_id]);
984
985 }
986
987 // check that at least 1 column is specified
988 if( empty( $fields ) ) {
989 continue;
990 }
991
992 // check that no required columns are missing
993 if( count( $fields ) < $table_field_count ) {
994 foreach( $table_fields as $field ) {
995 if( isset( $field['OPTS'] ) and ( in_array( 'NOTNULL', $field['OPTS'] ) || in_array( 'KEY', $field['OPTS'] ) ) && !in_array( 'AUTOINCREMENT', $field['OPTS'] ) ) {
996 continue(2);
997 }
998 }
999 }
1000
1001 // The rest of this method deals with updating existing data records.
1002
1003 if( !in_array( $table, $tables ) or ( $mode = $xmls->existingData() ) == XMLS_MODE_INSERT ) {
1004 // Table doesn't yet exist, so it's safe to insert.
1005 logMsg( "$table doesn't exist, inserting or mode is INSERT" );
1006 $sql[] = 'INSERT INTO '. $table .' ('. implode( ',', array_keys( $fields ) ) .') VALUES ('. implode( ',', $fields ) .')';
1007 continue;
1008 }
1009
1010 // Prepare to test for potential violations. Get primary keys and unique indexes
1011 $mfields = array_merge( $fields, $rawfields );
1012 $keyFields = array_intersect( $ukeys, array_keys( $mfields ) );
1013
1014 if( empty( $ukeys ) or count( $keyFields ) == 0 ) {
1015 // No unique keys in schema, so safe to insert
1016 logMsg( "Either schema or data has no unique keys, so safe to insert" );
1017 $sql[] = 'INSERT INTO '. $table .' ('. implode( ',', array_keys( $fields ) ) .') VALUES ('. implode( ',', $fields ) .')';
1018 continue;
1019 }
1020
1021 // Select record containing matching unique keys.
1022 $where = '';
1023 foreach( $ukeys as $key ) {
1024 if( isset( $mfields[$key] ) and $mfields[$key] ) {
1025 if( $where ) $where .= ' AND ';
1026 $where .= $key . ' = ' . $xmls->db->qstr( $mfields[$key] );
1027 }
1028 }
1029 $records = $xmls->db->Execute( 'SELECT * FROM ' . $table . ' WHERE ' . $where );
1030 switch( $records->RecordCount() ) {
1031 case 0:
1032 // No matching record, so safe to insert.
1033 logMsg( "No matching records. Inserting new row with unique data" );
1034 $sql[] = $xmls->db->GetInsertSQL( $records, $mfields );
1035 break;
1036 case 1:
1037 // Exactly one matching record, so we can update if the mode permits.
1038 logMsg( "One matching record..." );
1039 if( $mode == XMLS_MODE_UPDATE ) {
1040 logMsg( "...Updating existing row from unique data" );
1041 $sql[] = $xmls->db->GetUpdateSQL( $records, $mfields );
1042 }
1043 break;
1044 default:
1045 // More than one matching record; the result is ambiguous, so we must ignore the row.
1046 logMsg( "More than one matching record. Ignoring row." );
1047 }
1048 }
1049 return $sql;
1050 }
1051 }
1052
1053 /**
1054 * Creates the SQL to execute a list of provided SQL queries
1055 *
1056 * @package axmls
1057 * @access private
1058 */
1059 class dbQuerySet extends dbObject {
1060
1061 /**
1062 * @var array List of SQL queries
1063 */
1064 var $queries = array();
1065
1066 /**
1067 * @var string String used to build of a query line by line
1068 */
1069 var $query;
1070
1071 /**
1072 * @var string Query prefix key
1073 */
1074 var $prefixKey = '';
1075
1076 /**
1077 * @var boolean Auto prefix enable (TRUE)
1078 */
1079 var $prefixMethod = 'AUTO';
1080
1081 /**
1082 * Initializes the query set.
1083 *
1084 * @param object $parent Parent object
1085 * @param array $attributes Attributes
1086 */
1087 function dbQuerySet( &$parent, $attributes = NULL ) {
1088 $this->parent = $parent;
1089
1090 // Overrides the manual prefix key
1091 if( isset( $attributes['KEY'] ) ) {
1092 $this->prefixKey = $attributes['KEY'];
1093 }
1094
1095 $prefixMethod = isset( $attributes['PREFIXMETHOD'] ) ? strtoupper( trim( $attributes['PREFIXMETHOD'] ) ) : '';
1096
1097 // Enables or disables automatic prefix prepending
1098 switch( $prefixMethod ) {
1099 case 'AUTO':
1100 $this->prefixMethod = 'AUTO';
1101 break;
1102 case 'MANUAL':
1103 $this->prefixMethod = 'MANUAL';
1104 break;
1105 case 'NONE':
1106 $this->prefixMethod = 'NONE';
1107 break;
1108 }
1109 }
1110
1111 /**
1112 * XML Callback to process start elements. Elements currently
1113 * processed are: QUERY.
1114 *
1115 * @access private
1116 */
1117 function _tag_open( &$parser, $tag, $attributes ) {
1118 $this->currentElement = strtoupper( $tag );
1119
1120 switch( $this->currentElement ) {
1121 case 'QUERY':
1122 // Create a new query in a SQL queryset.
1123 // Ignore this query set if a platform is specified and it's different than the
1124 // current connection platform.
1125 if( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) ) {
1126 $this->newQuery();
1127 } else {
1128 $this->discardQuery();
1129 }
1130 break;
1131 default:
1132 // print_r( array( $tag, $attributes ) );
1133 }
1134 }
1135
1136 /**
1137 * XML Callback to process CDATA elements
1138 */
1139 function _tag_cdata( &$parser, $cdata ) {
1140 switch( $this->currentElement ) {
1141 // Line of queryset SQL data
1142 case 'QUERY':
1143 $this->buildQuery( $cdata );
1144 break;
1145 default:
1146
1147 }
1148 }
1149
1150 /**
1151 * XML Callback to process end elements
1152 *
1153 * @access private
1154 */
1155 function _tag_close( &$parser, $tag ) {
1156 $this->currentElement = '';
1157
1158 switch( strtoupper( $tag ) ) {
1159 case 'QUERY':
1160 // Add the finished query to the open query set.
1161 $this->addQuery();
1162 break;
1163 case 'SQL':
1164 $this->parent->addSQL( $this->create( $this->parent ) );
1165 xml_set_object( $parser, $this->parent );
1166 $this->destroy();
1167 break;
1168 default:
1169
1170 }
1171 }
1172
1173 /**
1174 * Re-initializes the query.
1175 *
1176 * @return boolean TRUE
1177 */
1178 function newQuery() {
1179 $this->query = '';
1180
1181 return TRUE;
1182 }
1183
1184 /**
1185 * Discards the existing query.
1186 *
1187 * @return boolean TRUE
1188 */
1189 function discardQuery() {
1190 unset( $this->query );
1191
1192 return TRUE;
1193 }
1194
1195 /**
1196 * Appends a line to a query that is being built line by line
1197 *
1198 * @param string $data Line of SQL data or NULL to initialize a new query
1199 * @return string SQL query string.
1200 */
1201 function buildQuery( $sql = NULL ) {
1202 if( !isset( $this->query ) OR empty( $sql ) ) {
1203 return FALSE;
1204 }
1205
1206 $this->query .= $sql;
1207
1208 return $this->query;
1209 }
1210
1211 /**
1212 * Adds a completed query to the query list
1213 *
1214 * @return string SQL of added query
1215 */
1216 function addQuery() {
1217 if( !isset( $this->query ) ) {
1218 return FALSE;
1219 }
1220
1221 $this->queries[] = $return = trim($this->query);
1222
1223 unset( $this->query );
1224
1225 return $return;
1226 }
1227
1228 /**
1229 * Creates and returns the current query set
1230 *
1231 * @param object $xmls adoSchema object
1232 * @return array Query set
1233 */
1234 function create( &$xmls ) {
1235 foreach( $this->queries as $id => $query ) {
1236 switch( $this->prefixMethod ) {
1237 case 'AUTO':
1238 // Enable auto prefix replacement
1239
1240 // Process object prefix.
1241 // Evaluate SQL statements to prepend prefix to objects
1242 $query = $this->prefixQuery( '/^\s*((?is)INSERT\s+(INTO\s+)?)((\w+\s*,?\s*)+)(\s.*$)/', $query, $xmls->objectPrefix );
1243 $query = $this->prefixQuery( '/^\s*((?is)UPDATE\s+(FROM\s+)?)((\w+\s*,?\s*)+)(\s.*$)/', $query, $xmls->objectPrefix );
1244 $query = $this->prefixQuery( '/^\s*((?is)DELETE\s+(FROM\s+)?)((\w+\s*,?\s*)+)(\s.*$)/', $query, $xmls->objectPrefix );
1245
1246 // SELECT statements aren't working yet
1247 #$data = preg_replace( '/(?ias)(^\s*SELECT\s+.*\s+FROM)\s+(\W\s*,?\s*)+((?i)\s+WHERE.*$)/', "\1 $prefix\2 \3", $data );
1248
1249 case 'MANUAL':
1250 // If prefixKey is set and has a value then we use it to override the default constant XMLS_PREFIX.
1251 // If prefixKey is not set, we use the default constant XMLS_PREFIX
1252 if( isset( $this->prefixKey ) AND( $this->prefixKey !== '' ) ) {
1253 // Enable prefix override
1254 $query = str_replace( $this->prefixKey, $xmls->objectPrefix, $query );
1255 } else {
1256 // Use default replacement
1257 $query = str_replace( XMLS_PREFIX , $xmls->objectPrefix, $query );
1258 }
1259 }
1260
1261 $this->queries[$id] = trim( $query );
1262 }
1263
1264 // Return the query set array
1265 return $this->queries;
1266 }
1267
1268 /**
1269 * Rebuilds the query with the prefix attached to any objects
1270 *
1271 * @param string $regex Regex used to add prefix
1272 * @param string $query SQL query string
1273 * @param string $prefix Prefix to be appended to tables, indices, etc.
1274 * @return string Prefixed SQL query string.
1275 */
1276 function prefixQuery( $regex, $query, $prefix = NULL ) {
1277 if( !isset( $prefix ) ) {
1278 return $query;
1279 }
1280
1281 if( preg_match( $regex, $query, $match ) ) {
1282 $preamble = $match[1];
1283 $postamble = $match[5];
1284 $objectList = explode( ',', $match[3] );
1285 // $prefix = $prefix . '_';
1286
1287 $prefixedList = '';
1288
1289 foreach( $objectList as $object ) {
1290 if( $prefixedList !== '' ) {
1291 $prefixedList .= ', ';
1292 }
1293
1294 $prefixedList .= $prefix . trim( $object );
1295 }
1296
1297 $query = $preamble . ' ' . $prefixedList . ' ' . $postamble;
1298 }
1299
1300 return $query;
1301 }
1302 }
1303
1304 /**
1305 * Loads and parses an XML file, creating an array of "ready-to-run" SQL statements
1306 *
1307 * This class is used to load and parse the XML file, to create an array of SQL statements
1308 * that can be used to build a database, and to build the database using the SQL array.
1309 *
1310 * @tutorial getting_started.pkg
1311 *
1312 * @author Richard Tango-Lowy & Dan Cech
1313 * @version $Revision: 1.62 $
1314 *
1315 * @package axmls
1316 */
1317 class adoSchema {
1318
1319 /**
1320 * @var array Array containing SQL queries to generate all objects
1321 * @access private
1322 */
1323 var $sqlArray;
1324
1325 /**
1326 * @var object ADOdb connection object
1327 * @access private
1328 */
1329 var $db;
1330
1331 /**
1332 * @var object ADOdb Data Dictionary
1333 * @access private
1334 */
1335 var $dict;
1336
1337 /**
1338 * @var string Current XML element
1339 * @access private
1340 */
1341 var $currentElement = '';
1342
1343 /**
1344 * @var string If set (to 'ALTER' or 'REPLACE'), upgrade an existing database
1345 * @access private
1346 */
1347 var $upgrade = '';
1348
1349 /**
1350 * @var string Optional object prefix
1351 * @access private
1352 */
1353 var $objectPrefix = '';
1354
1355 /**
1356 * @var long Original Magic Quotes Runtime value
1357 * @access private
1358 */
1359 var $mgq;
1360
1361 /**
1362 * @var long System debug
1363 * @access private
1364 */
1365 var $debug;
1366
1367 /**
1368 * @var string Regular expression to find schema version
1369 * @access private
1370 */
1371 var $versionRegex = '/<schema.*?( version="([^"]*)")?.*?>/';
1372
1373 /**
1374 * @var string Current schema version
1375 * @access private
1376 */
1377 var $schemaVersion;
1378
1379 /**
1380 * @var int Success of last Schema execution
1381 */
1382 var $success;
1383
1384 /**
1385 * @var bool Execute SQL inline as it is generated
1386 */
1387 var $executeInline;
1388
1389 /**
1390 * @var bool Continue SQL execution if errors occur
1391 */
1392 var $continueOnError;
1393
1394 /**
1395 * @var int How to handle existing data rows (insert, update, or ignore)
1396 */
1397 var $existingData;
1398
1399 /**
1400 * Creates an adoSchema object
1401 *
1402 * Creating an adoSchema object is the first step in processing an XML schema.
1403 * The only parameter is an ADOdb database connection object, which must already
1404 * have been created.
1405 *
1406 * @param object $db ADOdb database connection object.
1407 */
1408 function adoSchema( $db ) {
1409 // Initialize the environment
1410 $this->mgq = get_magic_quotes_runtime();
1411 #set_magic_quotes_runtime(0);
1412 ini_set("magic_quotes_runtime", 0);
1413
1414 $this->db = $db;
1415 $this->debug = $this->db->debug;
1416 $this->dict = NewDataDictionary( $this->db );
1417 $this->sqlArray = array();
1418 $this->schemaVersion = XMLS_SCHEMA_VERSION;
1419 $this->executeInline( XMLS_EXECUTE_INLINE );
1420 $this->continueOnError( XMLS_CONTINUE_ON_ERROR );
1421 $this->existingData( XMLS_EXISTING_DATA );
1422 $this->setUpgradeMethod();
1423 }
1424
1425 /**
1426 * Sets the method to be used for upgrading an existing database
1427 *
1428 * Use this method to specify how existing database objects should be upgraded.
1429 * The method option can be set to ALTER, REPLACE, BEST, or NONE. ALTER attempts to
1430 * alter each database object directly, REPLACE attempts to rebuild each object
1431 * from scratch, BEST attempts to determine the best upgrade method for each
1432 * object, and NONE disables upgrading.
1433 *
1434 * This method is not yet used by AXMLS, but exists for backward compatibility.
1435 * The ALTER method is automatically assumed when the adoSchema object is
1436 * instantiated; other upgrade methods are not currently supported.
1437 *
1438 * @param string $method Upgrade method (ALTER|REPLACE|BEST|NONE)
1439 * @returns string Upgrade method used
1440 */
1441 function SetUpgradeMethod( $method = '' ) {
1442 if( !is_string( $method ) ) {
1443 return FALSE;
1444 }
1445
1446 $method = strtoupper( $method );
1447
1448 // Handle the upgrade methods
1449 switch( $method ) {
1450 case 'ALTER':
1451 $this->upgrade = $method;
1452 break;
1453 case 'REPLACE':
1454 $this->upgrade = $method;
1455 break;
1456 case 'BEST':
1457 $this->upgrade = 'ALTER';
1458 break;
1459 case 'NONE':
1460 $this->upgrade = 'NONE';
1461 break;
1462 default:
1463 // Use default if no legitimate method is passed.
1464 $this->upgrade = XMLS_DEFAULT_UPGRADE_METHOD;
1465 }
1466
1467 return $this->upgrade;
1468 }
1469
1470 /**
1471 * Specifies how to handle existing data row when there is a unique key conflict.
1472 *
1473 * The existingData setting specifies how the parser should handle existing rows
1474 * when a unique key violation occurs during the insert. This can happen when inserting
1475 * data into an existing table with one or more primary keys or unique indexes.
1476 * The existingData method takes one of three options: XMLS_MODE_INSERT attempts
1477 * to always insert the data as a new row. In the event of a unique key violation,
1478 * the database will generate an error. XMLS_MODE_UPDATE attempts to update the
1479 * any existing rows with the new data based upon primary or unique key fields in
1480 * the schema. If the data row in the schema specifies no unique fields, the row
1481 * data will be inserted as a new row. XMLS_MODE_IGNORE specifies that any data rows
1482 * that would result in a unique key violation be ignored; no inserts or updates will
1483 * take place. For backward compatibility, the default setting is XMLS_MODE_INSERT,
1484 * but XMLS_MODE_UPDATE will generally be the most appropriate setting.
1485 *
1486 * @param int $mode XMLS_MODE_INSERT, XMLS_MODE_UPDATE, or XMLS_MODE_IGNORE
1487 * @return int current mode
1488 */
1489 function ExistingData( $mode = NULL ) {
1490 if( is_int( $mode ) ) {
1491 switch( $mode ) {
1492 case XMLS_MODE_UPDATE:
1493 $mode = XMLS_MODE_UPDATE;
1494 break;
1495 case XMLS_MODE_IGNORE:
1496 $mode = XMLS_MODE_IGNORE;
1497 break;
1498 case XMLS_MODE_INSERT:
1499 $mode = XMLS_MODE_INSERT;
1500 break;
1501 default:
1502 $mode = XMLS_EXISTING_DATA;
1503 break;
1504 }
1505 $this->existingData = $mode;
1506 }
1507
1508 return $this->existingData;
1509 }
1510
1511 /**
1512 * Enables/disables inline SQL execution.
1513 *
1514 * Call this method to enable or disable inline execution of the schema. If the mode is set to TRUE (inline execution),
1515 * AXMLS applies the SQL to the database immediately as each schema entity is parsed. If the mode
1516 * is set to FALSE (post execution), AXMLS parses the entire schema and you will need to call adoSchema::ExecuteSchema()
1517 * to apply the schema to the database.
1518 *
1519 * @param bool $mode execute
1520 * @return bool current execution mode
1521 *
1522 * @see ParseSchema(), ExecuteSchema()
1523 */
1524 function ExecuteInline( $mode = NULL ) {
1525 if( is_bool( $mode ) ) {
1526 $this->executeInline = $mode;
1527 }
1528
1529 return $this->executeInline;
1530 }
1531
1532 /**
1533 * Enables/disables SQL continue on error.
1534 *
1535 * Call this method to enable or disable continuation of SQL execution if an error occurs.
1536 * If the mode is set to TRUE (continue), AXMLS will continue to apply SQL to the database, even if an error occurs.
1537 * If the mode is set to FALSE (halt), AXMLS will halt execution of generated sql if an error occurs, though parsing
1538 * of the schema will continue.
1539 *
1540 * @param bool $mode execute
1541 * @return bool current continueOnError mode
1542 *
1543 * @see addSQL(), ExecuteSchema()
1544 */
1545 function ContinueOnError( $mode = NULL ) {
1546 if( is_bool( $mode ) ) {
1547 $this->continueOnError = $mode;
1548 }
1549
1550 return $this->continueOnError;
1551 }
1552
1553 /**
1554 * Loads an XML schema from a file and converts it to SQL.
1555 *
1556 * Call this method to load the specified schema (see the DTD for the proper format) from
1557 * the filesystem and generate the SQL necessary to create the database
1558 * described. This method automatically converts the schema to the latest
1559 * axmls schema version.
1560 * @see ParseSchemaString()
1561 *
1562 * @param string $file Name of XML schema file.
1563 * @param bool $returnSchema Return schema rather than parsing.
1564 * @return array Array of SQL queries, ready to execute
1565 */
1566 function ParseSchema( $filename, $returnSchema = FALSE ) {
1567 return $this->ParseSchemaString( $this->ConvertSchemaFile( $filename ), $returnSchema );
1568 }
1569
1570 /**
1571 * Loads an XML schema from a file and converts it to SQL.
1572 *
1573 * Call this method to load the specified schema directly from a file (see
1574 * the DTD for the proper format) and generate the SQL necessary to create
1575 * the database described by the schema. Use this method when you are dealing
1576 * with large schema files. Otherwise, ParseSchema() is faster.
1577 * This method does not automatically convert the schema to the latest axmls
1578 * schema version. You must convert the schema manually using either the
1579 * ConvertSchemaFile() or ConvertSchemaString() method.
1580 * @see ParseSchema()
1581 * @see ConvertSchemaFile()
1582 * @see ConvertSchemaString()
1583 *
1584 * @param string $file Name of XML schema file.
1585 * @param bool $returnSchema Return schema rather than parsing.
1586 * @return array Array of SQL queries, ready to execute.
1587 *
1588 * @deprecated Replaced by adoSchema::ParseSchema() and adoSchema::ParseSchemaString()
1589 * @see ParseSchema(), ParseSchemaString()
1590 */
1591 function ParseSchemaFile( $filename, $returnSchema = FALSE ) {
1592 // Open the file
1593 if( !($fp = fopen( $filename, 'r' )) ) {
1594 logMsg( 'Unable to open file' );
1595 return FALSE;
1596 }
1597
1598 // do version detection here
1599 if( $this->SchemaFileVersion( $filename ) != $this->schemaVersion ) {
1600 logMsg( 'Invalid Schema Version' );
1601 return FALSE;
1602 }
1603
1604 if( $returnSchema ) {
1605 $xmlstring = '';
1606 while( $data = fread( $fp, 4096 ) ) {
1607 $xmlstring .= $data . "\n";
1608 }
1609 return $xmlstring;
1610 }
1611
1612 $this->success = 2;
1613
1614 $xmlParser = $this->create_parser();
1615
1616 // Process the file
1617 while( $data = fread( $fp, 4096 ) ) {
1618 if( !xml_parse( $xmlParser, $data, feof( $fp ) ) ) {
1619 die( sprintf(
1620 "XML error: %s at line %d",
1621 xml_error_string( xml_get_error_code( $xmlParser) ),
1622 xml_get_current_line_number( $xmlParser)
1623 ) );
1624 }
1625 }
1626
1627 xml_parser_free( $xmlParser );
1628
1629 return $this->sqlArray;
1630 }
1631
1632 /**
1633 * Converts an XML schema string to SQL.
1634 *
1635 * Call this method to parse a string containing an XML schema (see the DTD for the proper format)
1636 * and generate the SQL necessary to create the database described by the schema.
1637 * @see ParseSchema()
1638 *
1639 * @param string $xmlstring XML schema string.
1640 * @param bool $returnSchema Return schema rather than parsing.
1641 * @return array Array of SQL queries, ready to execute.
1642 */
1643 function ParseSchemaString( $xmlstring, $returnSchema = FALSE ) {
1644 if( !is_string( $xmlstring ) OR empty( $xmlstring ) ) {
1645 logMsg( 'Empty or Invalid Schema' );
1646 return FALSE;
1647 }
1648
1649 // do version detection here
1650 if( $this->SchemaStringVersion( $xmlstring ) != $this->schemaVersion ) {
1651 logMsg( 'Invalid Schema Version' );
1652 return FALSE;
1653 }
1654
1655 if( $returnSchema ) {
1656 return $xmlstring;
1657 }
1658
1659 $this->success = 2;
1660
1661 $xmlParser = $this->create_parser();
1662
1663 if( !xml_parse( $xmlParser, $xmlstring, TRUE ) ) {
1664 die( sprintf(
1665 "XML error: %s at line %d",
1666 xml_error_string( xml_get_error_code( $xmlParser) ),
1667 xml_get_current_line_number( $xmlParser)
1668 ) );
1669 }
1670
1671 xml_parser_free( $xmlParser );
1672
1673 return $this->sqlArray;
1674 }
1675
1676 /**
1677 * Loads an XML schema from a file and converts it to uninstallation SQL.
1678 *
1679 * Call this method to load the specified schema (see the DTD for the proper format) from
1680 * the filesystem and generate the SQL necessary to remove the database described.
1681 * @see RemoveSchemaString()
1682 *
1683 * @param string $file Name of XML schema file.
1684 * @param bool $returnSchema Return schema rather than parsing.
1685 * @return array Array of SQL queries, ready to execute
1686 */
1687 function RemoveSchema( $filename, $returnSchema = FALSE ) {
1688 return $this->RemoveSchemaString( $this->ConvertSchemaFile( $filename ), $returnSchema );
1689 }
1690
1691 /**
1692 * Converts an XML schema string to uninstallation SQL.
1693 *
1694 * Call this method to parse a string containing an XML schema (see the DTD for the proper format)
1695 * and generate the SQL necessary to uninstall the database described by the schema.
1696 * @see RemoveSchema()
1697 *
1698 * @param string $schema XML schema string.
1699 * @param bool $returnSchema Return schema rather than parsing.
1700 * @return array Array of SQL queries, ready to execute.
1701 */
1702 function RemoveSchemaString( $schema, $returnSchema = FALSE ) {
1703
1704 // grab current version
1705 if( !( $version = $this->SchemaStringVersion( $schema ) ) ) {
1706 return FALSE;
1707 }
1708
1709 return $this->ParseSchemaString( $this->TransformSchema( $schema, 'remove-' . $version), $returnSchema );
1710 }
1711
1712 /**
1713 * Applies the current XML schema to the database (post execution).
1714 *
1715 * Call this method to apply the current schema (generally created by calling
1716 * ParseSchema() or ParseSchemaString() ) to the database (creating the tables, indexes,
1717 * and executing other SQL specified in the schema) after parsing.
1718 * @see ParseSchema(), ParseSchemaString(), ExecuteInline()
1719 *
1720 * @param array $sqlArray Array of SQL statements that will be applied rather than
1721 * the current schema.
1722 * @param boolean $continueOnErr Continue to apply the schema even if an error occurs.
1723 * @returns integer 0 if failure, 1 if errors, 2 if successful.
1724 */
1725 function ExecuteSchema( $sqlArray = NULL, $continueOnErr = NULL ) {
1726 if( !is_bool( $continueOnErr ) ) {
1727 $continueOnErr = $this->ContinueOnError();
1728 }
1729
1730 if( !isset( $sqlArray ) ) {
1731 $sqlArray = $this->sqlArray;
1732 }
1733
1734 if( !is_array( $sqlArray ) ) {
1735 $this->success = 0;
1736 } else {
1737 $this->success = $this->dict->ExecuteSQLArray( $sqlArray, $continueOnErr );
1738 }
1739
1740 return $this->success;
1741 }
1742
1743 /**
1744 * Returns the current SQL array.
1745 *
1746 * Call this method to fetch the array of SQL queries resulting from
1747 * ParseSchema() or ParseSchemaString().
1748 *
1749 * @param string $format Format: HTML, TEXT, or NONE (PHP array)
1750 * @return array Array of SQL statements or FALSE if an error occurs
1751 */
1752 function PrintSQL( $format = 'NONE' ) {
1753 $sqlArray = null;
1754 return $this->getSQL( $format, $sqlArray );
1755 }
1756
1757 /**
1758 * Saves the current SQL array to the local filesystem as a list of SQL queries.
1759 *
1760 * Call this method to save the array of SQL queries (generally resulting from a
1761 * parsed XML schema) to the filesystem.
1762 *
1763 * @param string $filename Path and name where the file should be saved.
1764 * @return boolean TRUE if save is successful, else FALSE.
1765 */
1766 function SaveSQL( $filename = './schema.sql' ) {
1767
1768 if( !isset( $sqlArray ) ) {
1769 $sqlArray = $this->sqlArray;
1770 }
1771 if( !isset( $sqlArray ) ) {
1772 return FALSE;
1773 }
1774
1775 $fp = fopen( $filename, "w" );
1776
1777 foreach( $sqlArray as $key => $query ) {
1778 fwrite( $fp, $query . ";\n" );
1779 }
1780 fclose( $fp );
1781 }
1782
1783 /**
1784 * Create an xml parser
1785 *
1786 * @return object PHP XML parser object
1787 *
1788 * @access private
1789 */
1790 function create_parser() {
1791 // Create the parser
1792 $xmlParser = xml_parser_create();
1793 xml_set_object( $xmlParser, $this );
1794
1795 // Initialize the XML callback functions
1796 xml_set_element_handler( $xmlParser, '_tag_open', '_tag_close' );
1797 xml_set_character_data_handler( $xmlParser, '_tag_cdata' );
1798
1799 return $xmlParser;
1800 }
1801
1802 /**
1803 * XML Callback to process start elements
1804 *
1805 * @access private
1806 */
1807 function _tag_open( &$parser, $tag, $attributes ) {
1808 switch( strtoupper( $tag ) ) {
1809 case 'TABLE':
1810 if( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) ) {
1811 $this->obj = new dbTable( $this, $attributes );
1812 xml_set_object( $parser, $this->obj );
1813 }
1814 break;
1815 case 'SQL':
1816 if( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) ) {
1817 $this->obj = new dbQuerySet( $this, $attributes );
1818 xml_set_object( $parser, $this->obj );
1819 }
1820 break;
1821 default:
1822 // print_r( array( $tag, $attributes ) );
1823 }
1824
1825 }
1826
1827 /**
1828 * XML Callback to process CDATA elements
1829 *
1830 * @access private
1831 */
1832 function _tag_cdata( &$parser, $cdata ) {
1833 }
1834
1835 /**
1836 * XML Callback to process end elements
1837 *
1838 * @access private
1839 * @internal
1840 */
1841 function _tag_close( &$parser, $tag ) {
1842
1843 }
1844
1845 /**
1846 * Converts an XML schema string to the specified DTD version.
1847 *
1848 * Call this method to convert a string containing an XML schema to a different AXMLS
1849 * DTD version. For instance, to convert a schema created for an pre-1.0 version for
1850 * AXMLS (DTD version 0.1) to a newer version of the DTD (e.g. 0.2). If no DTD version
1851 * parameter is specified, the schema will be converted to the current DTD version.
1852 * If the newFile parameter is provided, the converted schema will be written to the specified
1853 * file.
1854 * @see ConvertSchemaFile()
1855 *
1856 * @param string $schema String containing XML schema that will be converted.
1857 * @param string $newVersion DTD version to convert to.
1858 * @param string $newFile File name of (converted) output file.
1859 * @return string Converted XML schema or FALSE if an error occurs.
1860 */
1861 function ConvertSchemaString( $schema, $newVersion = NULL, $newFile = NULL ) {
1862
1863 // grab current version
1864 if( !( $version = $this->SchemaStringVersion( $schema ) ) ) {
1865 return FALSE;
1866 }
1867
1868 if( !isset ($newVersion) ) {
1869 $newVersion = $this->schemaVersion;
1870 }
1871
1872 if( $version == $newVersion ) {
1873 $result = $schema;
1874 } else {
1875 $result = $this->TransformSchema( $schema, 'convert-' . $version . '-' . $newVersion);
1876 }
1877
1878 if( is_string( $result ) AND is_string( $newFile ) AND ( $fp = fopen( $newFile, 'w' ) ) ) {
1879 fwrite( $fp, $result );
1880 fclose( $fp );
1881 }
1882
1883 return $result;
1884 }
1885
1886 /*
1887 // compat for pre-4.3 - jlim
1888 function _file_get_contents($path)
1889 {
1890 if (function_exists('file_get_contents')) return file_get_contents($path);
1891 return join('',file($path));
1892 }*/
1893
1894 /**
1895 * Converts an XML schema file to the specified DTD version.
1896 *
1897 * Call this method to convert the specified XML schema file to a different AXMLS
1898 * DTD version. For instance, to convert a schema created for an pre-1.0 version for
1899 * AXMLS (DTD version 0.1) to a newer version of the DTD (e.g. 0.2). If no DTD version
1900 * parameter is specified, the schema will be converted to the current DTD version.
1901 * If the newFile parameter is provided, the converted schema will be written to the specified
1902 * file.
1903 * @see ConvertSchemaString()
1904 *
1905 * @param string $filename Name of XML schema file that will be converted.
1906 * @param string $newVersion DTD version to convert to.
1907 * @param string $newFile File name of (converted) output file.
1908 * @return string Converted XML schema or FALSE if an error occurs.
1909 */
1910 function ConvertSchemaFile( $filename, $newVersion = NULL, $newFile = NULL ) {
1911
1912 // grab current version
1913 if( !( $version = $this->SchemaFileVersion( $filename ) ) ) {
1914 return FALSE;
1915 }
1916
1917 if( !isset ($newVersion) ) {
1918 $newVersion = $this->schemaVersion;
1919 }
1920
1921 if( $version == $newVersion ) {
1922 $result = _file_get_contents( $filename );
1923
1924 // remove unicode BOM if present
1925 if( substr( $result, 0, 3 ) == sprintf( '%c%c%c', 239, 187, 191 ) ) {
1926 $result = substr( $result, 3 );
1927 }
1928 } else {
1929 $result = $this->TransformSchema( $filename, 'convert-' . $version . '-' . $newVersion, 'file' );
1930 }
1931
1932 if( is_string( $result ) AND is_string( $newFile ) AND ( $fp = fopen( $newFile, 'w' ) ) ) {
1933 fwrite( $fp, $result );
1934 fclose( $fp );
1935 }
1936
1937 return $result;
1938 }
1939
1940 function TransformSchema( $schema, $xsl, $schematype='string' )
1941 {
1942 // Fail if XSLT extension is not available
1943 if( ! function_exists( 'xslt_create' ) ) {
1944 return FALSE;
1945 }
1946
1947 $xsl_file = dirname( __FILE__ ) . '/xsl/' . $xsl . '.xsl';
1948
1949 // look for xsl
1950 if( !is_readable( $xsl_file ) ) {
1951 return FALSE;
1952 }
1953
1954 switch( $schematype )
1955 {
1956 case 'file':
1957 if( !is_readable( $schema ) ) {
1958 return FALSE;
1959 }
1960
1961 $schema = _file_get_contents( $schema );
1962 break;
1963 case 'string':
1964 default:
1965 if( !is_string( $schema ) ) {
1966 return FALSE;
1967 }
1968 }
1969
1970 $arguments = array (
1971 '/_xml' => $schema,
1972 '/_xsl' => _file_get_contents( $xsl_file )
1973 );
1974
1975 // create an XSLT processor
1976 $xh = xslt_create ();
1977
1978 // set error handler
1979 xslt_set_error_handler ($xh, array (&$this, 'xslt_error_handler'));
1980
1981 // process the schema
1982 $result = xslt_process ($xh, 'arg:/_xml', 'arg:/_xsl', NULL, $arguments);
1983
1984 xslt_free ($xh);
1985
1986 return $result;
1987 }
1988
1989 /**
1990 * Processes XSLT transformation errors
1991 *
1992 * @param object $parser XML parser object
1993 * @param integer $errno Error number
1994 * @param integer $level Error level
1995 * @param array $fields Error information fields
1996 *
1997 * @access private
1998 */
1999 function xslt_error_handler( $parser, $errno, $level, $fields ) {
2000 if( is_array( $fields ) ) {
2001 $msg = array(
2002 'Message Type' => ucfirst( $fields['msgtype'] ),
2003 'Message Code' => $fields['code'],
2004 'Message' => $fields['msg'],
2005 'Error Number' => $errno,
2006 'Level' => $level
2007 );
2008
2009 switch( $fields['URI'] ) {
2010 case 'arg:/_xml':
2011 $msg['Input'] = 'XML';
2012 break;
2013 case 'arg:/_xsl':
2014 $msg['Input'] = 'XSL';
2015 break;
2016 default:
2017 $msg['Input'] = $fields['URI'];
2018 }
2019
2020 $msg['Line'] = $fields['line'];
2021 } else {
2022 $msg = array(
2023 'Message Type' => 'Error',
2024 'Error Number' => $errno,
2025 'Level' => $level,
2026 'Fields' => var_export( $fields, TRUE )
2027 );
2028 }
2029
2030 $error_details = $msg['Message Type'] . ' in XSLT Transformation' . "\n"
2031 . '<table>' . "\n";
2032
2033 foreach( $msg as $label => $details ) {
2034 $error_details .= '<tr><td><b>' . $label . ': </b></td><td>' . htmlentities( $details ) . '</td></tr>' . "\n";
2035 }
2036
2037 $error_details .= '</table>';
2038
2039 trigger_error( $error_details, E_USER_ERROR );
2040 }
2041
2042 /**
2043 * Returns the AXMLS Schema Version of the requested XML schema file.
2044 *
2045 * Call this method to obtain the AXMLS DTD version of the requested XML schema file.
2046 * @see SchemaStringVersion()
2047 *
2048 * @param string $filename AXMLS schema file
2049 * @return string Schema version number or FALSE on error
2050 */
2051 function SchemaFileVersion( $filename ) {
2052 // Open the file
2053 if( !($fp = fopen( $filename, 'r' )) ) {
2054 // die( 'Unable to open file' );
2055 return FALSE;
2056 }
2057
2058 // Process the file
2059 while( $data = fread( $fp, 4096 ) ) {
2060 if( preg_match( $this->versionRegex, $data, $matches ) ) {
2061 return !empty( $matches[2] ) ? $matches[2] : XMLS_DEFAULT_SCHEMA_VERSION;
2062 }
2063 }
2064
2065 return FALSE;
2066 }
2067
2068 /**
2069 * Returns the AXMLS Schema Version of the provided XML schema string.
2070 *
2071 * Call this method to obtain the AXMLS DTD version of the provided XML schema string.
2072 * @see SchemaFileVersion()
2073 *
2074 * @param string $xmlstring XML schema string
2075 * @return string Schema version number or FALSE on error
2076 */
2077 function SchemaStringVersion( $xmlstring ) {
2078 if( !is_string( $xmlstring ) OR empty( $xmlstring ) ) {
2079 return FALSE;
2080 }
2081
2082 if( preg_match( $this->versionRegex, $xmlstring, $matches ) ) {
2083 return !empty( $matches[2] ) ? $matches[2] : XMLS_DEFAULT_SCHEMA_VERSION;
2084 }
2085
2086 return FALSE;
2087 }
2088
2089 /**
2090 * Extracts an XML schema from an existing database.
2091 *
2092 * Call this method to create an XML schema string from an existing database.
2093 * If the data parameter is set to TRUE, AXMLS will include the data from the database
2094 * in the schema.
2095 *
2096 * @param boolean $data Include data in schema dump
2097 * @indent string indentation to use
2098 * @prefix string extract only tables with given prefix
2099 * @stripprefix strip prefix string when storing in XML schema
2100 * @return string Generated XML schema
2101 */
2102 function ExtractSchema( $data = FALSE, $indent = ' ', $prefix = '' , $stripprefix=false) {
2103 $old_mode = $this->db->SetFetchMode( ADODB_FETCH_NUM );
2104
2105 $schema = '<?xml version="1.0"?>' . "\n"
2106 . '<schema version="' . $this->schemaVersion . '">' . "\n";
2107
2108 if( is_array( $tables = $this->db->MetaTables( 'TABLES' , ($prefix) ? $prefix.'%' : '') ) ) {
2109 foreach( $tables as $table ) {
2110 if ($stripprefix) $table = str_replace(str_replace('\\_', '_', $pfx ), '', $table);
2111 $schema .= $indent . '<table name="' . htmlentities( $table ) . '">' . "\n";
2112
2113 // grab details from database
2114 $rs = $this->db->Execute( 'SELECT * FROM ' . $table . ' WHERE -1' );
2115 $fields = $this->db->MetaColumns( $table );
2116 $indexes = $this->db->MetaIndexes( $table );
2117
2118 if( is_array( $fields ) ) {
2119 foreach( $fields as $details ) {
2120 $extra = '';
2121 $content = array();
2122
2123 if( isset($details->max_length) && $details->max_length > 0 ) {
2124 $extra .= ' size="' . $details->max_length . '"';
2125 }
2126
2127 if( isset($details->primary_key) && $details->primary_key ) {
2128 $content[] = '<KEY/>';
2129 } elseif( isset($details->not_null) && $details->not_null ) {
2130 $content[] = '<NOTNULL/>';
2131 }
2132
2133 if( isset($details->has_default) && $details->has_default ) {
2134 $content[] = '<DEFAULT value="' . htmlentities( $details->default_value ) . '"/>';
2135 }
2136
2137 if( isset($details->auto_increment) && $details->auto_increment ) {
2138 $content[] = '<AUTOINCREMENT/>';
2139 }
2140
2141 if( isset($details->unsigned) && $details->unsigned ) {
2142 $content[] = '<UNSIGNED/>';
2143 }
2144
2145 // this stops the creation of 'R' columns,
2146 // AUTOINCREMENT is used to create auto columns
2147 $details->primary_key = 0;
2148 $type = $rs->MetaType( $details );
2149
2150 $schema .= str_repeat( $indent, 2 ) . '<field name="' . htmlentities( $details->name ) . '" type="' . $type . '"' . $extra;
2151
2152 if( !empty( $content ) ) {
2153 $schema .= ">\n" . str_repeat( $indent, 3 )
2154 . implode( "\n" . str_repeat( $indent, 3 ), $content ) . "\n"
2155 . str_repeat( $indent, 2 ) . '</field>' . "\n";
2156 } else {
2157 $schema .= "/>\n";
2158 }
2159 }
2160 }
2161
2162 if( is_array( $indexes ) ) {
2163 foreach( $indexes as $index => $details ) {
2164 $schema .= str_repeat( $indent, 2 ) . '<index name="' . $index . '">' . "\n";
2165
2166 if( $details['unique'] ) {
2167 $schema .= str_repeat( $indent, 3 ) . '<UNIQUE/>' . "\n";
2168 }
2169
2170 foreach( $details['columns'] as $column ) {
2171 $schema .= str_repeat( $indent, 3 ) . '<col>' . htmlentities( $column ) . '</col>' . "\n";
2172 }
2173
2174 $schema .= str_repeat( $indent, 2 ) . '</index>' . "\n";
2175 }
2176 }
2177
2178 if( $data ) {
2179 $rs = $this->db->Execute( 'SELECT * FROM ' . $table );
2180
2181 if( is_object( $rs ) && !$rs->EOF ) {
2182 $schema .= str_repeat( $indent, 2 ) . "<data>\n";
2183
2184 while( $row = $rs->FetchRow() ) {
2185 foreach( $row as $key => $val ) {
2186 if ( $val != htmlentities( $val ) ) {
2187 $row[$key] = '<![CDATA[' . $val . ']]>';
2188 }
2189 }
2190
2191 $schema .= str_repeat( $indent, 3 ) . '<row><f>' . implode( '</f><f>', $row ) . "</f></row>\n";
2192 }
2193
2194 $schema .= str_repeat( $indent, 2 ) . "</data>\n";
2195 }
2196 }
2197
2198 $schema .= $indent . "</table>\n";
2199 }
2200 }
2201
2202 $this->db->SetFetchMode( $old_mode );
2203
2204 $schema .= '</schema>';
2205 return $schema;
2206 }
2207
2208 /**
2209 * Sets a prefix for database objects
2210 *
2211 * Call this method to set a standard prefix that will be prepended to all database tables
2212 * and indices when the schema is parsed. Calling setPrefix with no arguments clears the prefix.
2213 *
2214 * @param string $prefix Prefix that will be prepended.
2215 * @param boolean $underscore If TRUE, automatically append an underscore character to the prefix.
2216 * @return boolean TRUE if successful, else FALSE
2217 */
2218 function SetPrefix( $prefix = '', $underscore = TRUE ) {
2219 switch( TRUE ) {
2220 // clear prefix
2221 case empty( $prefix ):
2222 logMsg( 'Cleared prefix' );
2223 $this->objectPrefix = '';
2224 return TRUE;
2225 // prefix too long
2226 case strlen( $prefix ) > XMLS_PREFIX_MAXLEN:
2227 // prefix contains invalid characters
2228 case !preg_match( '/^[a-z][a-z0-9_]+$/i', $prefix ):
2229 logMsg( 'Invalid prefix: ' . $prefix );
2230 return FALSE;
2231 }
2232
2233 if( $underscore AND substr( $prefix, -1 ) != '_' ) {
2234 $prefix .= '_';
2235 }
2236
2237 // prefix valid
2238 logMsg( 'Set prefix: ' . $prefix );
2239 $this->objectPrefix = $prefix;
2240 return TRUE;
2241 }
2242
2243 /**
2244 * Returns an object name with the current prefix prepended.
2245 *
2246 * @param string $name Name
2247 * @return string Prefixed name
2248 *
2249 * @access private
2250 */
2251 function prefix( $name = '' ) {
2252 // if prefix is set
2253 if( !empty( $this->objectPrefix ) ) {
2254 // Prepend the object prefix to the table name
2255 // prepend after quote if used
2256 return preg_replace( '/^(`?)(.+)$/', '$1' . $this->objectPrefix . '$2', $name );
2257 }
2258
2259 // No prefix set. Use name provided.
2260 return $name;
2261 }
2262
2263 /**
2264 * Checks if element references a specific platform
2265 *
2266 * @param string $platform Requested platform
2267 * @returns boolean TRUE if platform check succeeds
2268 *
2269 * @access private
2270 */
2271 function supportedPlatform( $platform = NULL ) {
2272 if( !empty( $platform ) ) {
2273 $regex = '/(^|\|)' . $this->db->databaseType . '(\||$)/i';
2274
2275 if( preg_match( '/^- /', $platform ) ) {
2276 if (preg_match ( $regex, substr( $platform, 2 ) ) ) {
2277 logMsg( 'Platform ' . $platform . ' is NOT supported' );
2278 return FALSE;
2279 }
2280 } else {
2281 if( !preg_match ( $regex, $platform ) ) {
2282 logMsg( 'Platform ' . $platform . ' is NOT supported' );
2283 return FALSE;
2284 }
2285 }
2286 }
2287
2288 logMsg( 'Platform ' . $platform . ' is supported' );
2289 return TRUE;
2290 }
2291
2292 /**
2293 * Clears the array of generated SQL.
2294 *
2295 * @access private
2296 */
2297 function clearSQL() {
2298 $this->sqlArray = array();
2299 }
2300
2301 /**
2302 * Adds SQL into the SQL array.
2303 *
2304 * @param mixed $sql SQL to Add
2305 * @return boolean TRUE if successful, else FALSE.
2306 *
2307 * @access private
2308 */
2309 function addSQL( $sql = NULL ) {
2310 if( is_array( $sql ) ) {
2311 foreach( $sql as $line ) {
2312 $this->addSQL( $line );
2313 }
2314
2315 return TRUE;
2316 }
2317
2318 if( is_string( $sql ) ) {
2319 $this->sqlArray[] = $sql;
2320
2321 // if executeInline is enabled, and either no errors have occurred or continueOnError is enabled, execute SQL.
2322 if( $this->ExecuteInline() && ( $this->success == 2 || $this->ContinueOnError() ) ) {
2323 $saved = $this->db->debug;
2324 $this->db->debug = $this->debug;
2325 $ok = $this->db->Execute( $sql );
2326 $this->db->debug = $saved;
2327
2328 if( !$ok ) {
2329 if( $this->debug ) {
2330 ADOConnection::outp( $this->db->ErrorMsg() );
2331 }
2332
2333 $this->success = 1;
2334 }
2335 }
2336
2337 return TRUE;
2338 }
2339
2340 return FALSE;
2341 }
2342
2343 /**
2344 * Gets the SQL array in the specified format.
2345 *
2346 * @param string $format Format
2347 * @return mixed SQL
2348 *
2349 * @access private
2350 */
2351 function getSQL( $format = NULL, $sqlArray = NULL ) {
2352 if( !is_array( $sqlArray ) ) {
2353 $sqlArray = $this->sqlArray;
2354 }
2355
2356 if( !is_array( $sqlArray ) ) {
2357 return FALSE;
2358 }
2359
2360 switch( strtolower( $format ) ) {
2361 case 'string':
2362 case 'text':
2363 return !empty( $sqlArray ) ? implode( ";\n\n", $sqlArray ) . ';' : '';
2364 case'html':
2365 return !empty( $sqlArray ) ? nl2br( htmlentities( implode( ";\n\n", $sqlArray ) . ';' ) ) : '';
2366 }
2367
2368 return $this->sqlArray;
2369 }
2370
2371 /**
2372 * Destroys an adoSchema object.
2373 *
2374 * Call this method to clean up after an adoSchema object that is no longer in use.
2375 * @deprecated adoSchema now cleans up automatically.
2376 */
2377 function Destroy() {
2378 ini_set("magic_quotes_runtime", $this->mgq );
2379 #set_magic_quotes_runtime( $this->mgq );
2380 unset( $this );
2381 }
2382 }
2383
2384 /**
2385 * Message logging function
2386 *
2387 * @access private
2388 */
2389 function logMsg( $msg, $title = NULL, $force = FALSE ) {
2390 if( XMLS_DEBUG or $force ) {
2391 echo '<pre>';
2392
2393 if( isset( $title ) ) {
2394 echo '<h3>' . htmlentities( $title ) . '</h3>';
2395 }
2396
2397 if( @is_object( $this ) ) {
2398 echo '[' . get_class( $this ) . '] ';
2399 }
2400
2401 print_r( $msg );
2402
2403 echo '</pre>';
2404 }
2405 }