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