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