1<?php
2// +----------------------------------------------------------------------+
3// | PHP Version 4                                                        |
4// +----------------------------------------------------------------------+
5// | Copyright (c) 1998-2004 Manuel Lemos, Tomas V.V.Cox,                 |
6// | Stig. S. Bakken, Lukas Smith                                         |
7// | All rights reserved.                                                 |
8// +----------------------------------------------------------------------+
9// | MDB is a merge of PEAR DB and Metabases that provides a unified DB   |
10// | API as well as database abstraction for PHP applications.            |
11// | This LICENSE is in the BSD license style.                            |
12// |                                                                      |
13// | Redistribution and use in source and binary forms, with or without   |
14// | modification, are permitted provided that the following conditions   |
15// | are met:                                                             |
16// |                                                                      |
17// | Redistributions of source code must retain the above copyright       |
18// | notice, this list of conditions and the following disclaimer.        |
19// |                                                                      |
20// | Redistributions in binary form must reproduce the above copyright    |
21// | notice, this list of conditions and the following disclaimer in the  |
22// | documentation and/or other materials provided with the distribution. |
23// |                                                                      |
24// | Neither the name of Manuel Lemos, Tomas V.V.Cox, Stig. S. Bakken,    |
25// | Lukas Smith nor the names of his contributors may be used to endorse |
26// | or promote products derived from this software without specific prior|
27// | written permission.                                                  |
28// |                                                                      |
29// | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS  |
30// | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT    |
31// | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS    |
32// | FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE      |
33// | REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,          |
34// | INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, |
35// | BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS|
36// |  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED  |
37// | AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT          |
38// | LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY|
39// | WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE          |
40// | POSSIBILITY OF SUCH DAMAGE.                                          |
41// +----------------------------------------------------------------------+
42// | Author: Lukas Smith <smith@backendmedia.com>                         |
43// +----------------------------------------------------------------------+
44//
45// $Id: metabase_wrapper.php,v 1.50.4.1 2004/01/08 13:43:02 lsmith Exp $
46//
47
48MDB::loadFile('Date');
49
50/**
51 * Wrapper that makes MDB behave like Metabase
52 *
53 * @package MDB
54 * @category Database
55 * @author  Lukas Smith <smith@backendmedia.com>
56 */
57
58$lob_error = '';
59
60function MetabaseSetupDatabase($arguments, &$database)
61{
62    _convertArguments($arguments, $dsninfo, $options);
63    $db =& MDB::connect($dsninfo, $options);
64
65    if (MDB::isError($db) || !is_object($db)) {
66        $database = 0;
67        return($db->getMessage());
68    }
69    $database = $db->database;
70    return('');
71}
72
73function MetabaseSetupDatabaseObject($arguments, &$db)
74{
75    _convertArguments($arguments, $dsninfo, $options);
76    $db =& MDB::connect($dsninfo, $options);
77
78    if (MDB::isError($db) || !is_object($db)) {
79        return($db->getMessage());
80    }
81    return('');
82}
83
84function _convertArguments($arguments, &$dsninfo, &$options)
85{
86    if (isset($arguments['Type'])) {
87        $dsninfo['phptype'] = $arguments['Type'];
88    }
89    if (isset($arguments['User'])) {
90        $dsninfo['username'] = $arguments['User'];
91    }
92    if(isset($arguments['Password'])) {
93        $dsninfo['password'] = $arguments['Password'];
94    }
95    if(isset($arguments['Host'])) {
96        $dsninfo['hostspec'] = $arguments['Host'];
97    }
98    if(isset($arguments['Options']['Port'])) {
99       $dsninfo['port'] = $arguments['Options']['Port'];
100       unset($arguments['Options']['Port']);
101    }
102
103    if (isset($arguments['Persistent'])) {
104        $options['persistent'] = TRUE;
105    }
106    if(isset($arguments['Debug'])) {
107        $options['debug'] = $arguments['Debug'];
108    }
109    if(isset($arguments['DecimalPlaces'])) {
110        $options['decimal_places'] = $arguments['DecimalPlaces'];
111    }
112    if(isset($arguments['LOBBufferLength'])) {
113        $options['LOBbufferlength'] = $arguments['LOBBufferLength'];
114    }
115    if(isset($arguments['LogLineBreak'])) {
116        $options['loglinebreak'] = $arguments['LogLineBreak'];
117    }
118
119    $options['seqname_format'] = '_sequence_%s';
120    if(isset($arguments['Options']) && is_array($arguments['Options'])) {
121       $options = array_merge($options, $arguments['Options']);
122    }
123}
124
125function MetabaseCloseSetup($database)
126{
127    global $_MDB_databases;
128
129    $_MDB_databases[$database]->disconnect();
130    unset($_MDB_databases[$database]);
131}
132
133function MetabaseQuery($database, $query)
134{
135    global $_MDB_databases;
136    $result = $_MDB_databases[$database]->query($query);
137    if (MDB::isError($result)) {
138        $_MDB_databases[$database]->setError('Query', $result->getMessage());
139        return(0);
140    } else {
141        return($result);
142    }
143}
144
145function MetabaseQueryField($database, $query, &$field, $type = 'text')
146{
147    global $_MDB_databases;
148    $result = $_MDB_databases[$database]->queryOne($query, $type);
149    if (MDB::isError($result)) {
150        $_MDB_databases[$database]->setError('QueryField', $result->getMessage());
151        return(0);
152    } else {
153        $field = $result;
154        return(1);
155    }
156}
157
158function MetabaseQueryRow($database, $query, &$row, $types = '')
159{
160    global $_MDB_databases;
161    $result = $_MDB_databases[$database]->queryRow($query, $types);
162    if (MDB::isError($result)) {
163        $_MDB_databases[$database]->setError('QueryRow', $result->getMessage());
164        return(0);
165    } else {
166        $row = $result;
167        return(1);
168    }
169}
170
171function MetabaseQueryColumn($database, $query, &$column, $type = 'text')
172{
173    global $_MDB_databases;
174    $result = $_MDB_databases[$database]->queryCol($query, $type);
175    if (MDB::isError($result)) {
176        $_MDB_databases[$database]->setError('QueryColumn', $result->getMessage());
177        return(0);
178    } else {
179        $column = $result;
180        return(1);
181    }
182}
183
184function MetabaseQueryAll($database, $query, &$all, $types = '')
185{
186    global $_MDB_databases;
187    $result = $_MDB_databases[$database]->queryAll($query, $types);
188    if (MDB::isError($result)) {
189        $_MDB_databases[$database]->setError('QueryAll', $result->getMessage());
190        return(0);
191    } else {
192        $all = $result;
193        return(1);
194    }
195}
196
197function MetabaseReplace($database, $table, &$fields)
198{
199    global $_MDB_databases;
200    for($count = count($fields), reset($fields), $field = 0;
201        $field < $count;
202        next($fields), $field++)
203    {
204        $name = key($fields);
205        if(!isset($fields[$name]['Type'])) {
206            $fields[$name]['Type'] = 'text';
207        }
208    }
209    $result = $_MDB_databases[$database]->replace($table, $fields);
210    if (MDB::isError($result)) {
211        $_MDB_databases[$database]->setError('Replace', $result->getMessage());
212        return(0);
213    } else {
214        return(1);
215    }
216}
217
218function MetabasePrepareQuery($database, $query)
219{
220    global $_MDB_databases;
221    $result = $_MDB_databases[$database]->prepareQuery($query);
222    if (MDB::isError($result)) {
223        $_MDB_databases[$database]->setError('PrepareQuery', $result->getMessage());
224        return(0);
225    } else {
226        return($result);
227    }
228}
229
230function MetabaseFreePreparedQuery($database, $prepared_query)
231{
232    global $_MDB_databases;
233    $result = $_MDB_databases[$database]->freePreparedQuery($prepared_query);
234    if (MDB::isError($result)) {
235        $_MDB_databases[$database]->setError('FreePreparedQuery', $result->getMessage());
236        return(0);
237    } else {
238        return($result);
239    }
240}
241
242function MetabaseExecuteQuery($database, $prepared_query)
243{
244    global $_MDB_databases;
245    $result = $_MDB_databases[$database]->executeQuery($prepared_query);
246    if (MDB::isError($result)) {
247        $_MDB_databases[$database]->setError('ExecuteQuery', $result->getMessage());
248        return(0);
249    } else {
250        return($result);
251    }
252}
253
254function MetabaseQuerySet($database, $prepared_query, $parameter, $type, $value, $is_null = 0, $field = '')
255{
256    global $_MDB_databases;
257    $result = $_MDB_databases[$database]->setParam($prepared_query, $parameter, $type, $value, $is_null, $field);
258    if (MDB::isError($result)) {
259        $_MDB_databases[$database]->setError('QuerySet', $result->getMessage());
260        return(0);
261    } else {
262        return(1);
263    }
264}
265
266function MetabaseQuerySetNull($database, $prepared_query, $parameter, $type)
267{
268    global $_MDB_databases;
269    $result = $_MDB_databases[$database]->setParamNull($prepared_query, $parameter, $type);
270    if (MDB::isError($result)) {
271        $_MDB_databases[$database]->setError('QuerySetNull', $result->getMessage());
272        return(0);
273    } else {
274        return(1);
275    }
276}
277
278function MetabaseQuerySetText($database, $prepared_query, $parameter, $value)
279{
280    global $_MDB_databases;
281    $result = $_MDB_databases[$database]->setParamText($prepared_query, $parameter, $value);
282    if (MDB::isError($result)) {
283        $_MDB_databases[$database]->setError('QuerySetText', $result->getMessage());
284        return(0);
285    } else {
286        return(1);
287    }
288}
289
290function MetabaseQuerySetCLOB($database, $prepared_query, $parameter, $value, $field)
291{
292    global $_MDB_databases;
293    $result = $_MDB_databases[$database]->setParamClob($prepared_query, $parameter, $value, $field);
294    if (MDB::isError($result)) {
295        $_MDB_databases[$database]->setError('QuerySetCLOB', $result->getMessage());
296        return(0);
297    } else {
298        return(1);
299    }
300}
301
302function MetabaseQuerySetBLOB($database, $prepared_query, $parameter, $value, $field)
303{
304    global $_MDB_databases;
305    $result = $_MDB_databases[$database]->setParamBlob($prepared_query, $parameter, $value, $field);
306    if (MDB::isError($result)) {
307        $_MDB_databases[$database]->setError('QuerySetBLOB', $result->getMessage());
308        return(0);
309    } else {
310        return(1);
311    }
312}
313
314function MetabaseQuerySetInteger($database, $prepared_query, $parameter, $value)
315{
316    global $_MDB_databases;
317    $result = $_MDB_databases[$database]->setParamInteger($prepared_query, $parameter, $value);
318    if (MDB::isError($result)) {
319        $_MDB_databases[$database]->setError('QuerySetInteger', $result->getMessage());
320        return(0);
321    } else {
322        return(1);
323    }
324}
325
326function MetabaseQuerySetBoolean($database, $prepared_query, $parameter, $value)
327{
328    global $_MDB_databases;
329    $result = $_MDB_databases[$database]->setParamBoolean($prepared_query, $parameter, $value);
330    if (MDB::isError($result)) {
331        $_MDB_databases[$database]->setError('QuerySetBoolean', $result->getMessage());
332        return(0);
333    } else {
334        return(1);
335    }
336}
337
338function MetabaseQuerySetDate($database, $prepared_query, $parameter, $value)
339{
340    global $_MDB_databases;
341    $result = $_MDB_databases[$database]->setParamDate($prepared_query, $parameter, $value);
342    if (MDB::isError($result)) {
343        $_MDB_databases[$database]->setError('QuerySetDate(', $result->getMessage());
344        return(0);
345    } else {
346        return(1);
347    }
348}
349
350function MetabaseQuerySetTimestamp($database, $prepared_query, $parameter, $value)
351{
352    global $_MDB_databases;
353    $result = $_MDB_databases[$database]->setParamTimestamp($prepared_query, $parameter, $value);
354    if (MDB::isError($result)) {
355        $_MDB_databases[$database]->setError('QuerySetTimestamp', $result->getMessage());
356        return(0);
357    } else {
358        return(1);
359    }
360}
361
362function MetabaseQuerySetTime($database, $prepared_query, $parameter, $value)
363{
364    global $_MDB_databases;
365    $result = $_MDB_databases[$database]->setParamTime($prepared_query, $parameter, $value);
366    if (MDB::isError($result)) {
367        $_MDB_databases[$database]->setError('QuerySetTime', $result->getMessage());
368        return(0);
369    } else {
370        return(1);
371    }
372}
373
374function MetabaseQuerySetFloat($database, $prepared_query, $parameter, $value)
375{
376    global $_MDB_databases;
377    $result = $_MDB_databases[$database]->setParamFloat($prepared_query, $parameter, $value);
378    if (MDB::isError($result)) {
379        $_MDB_databases[$database]->setError('QuerySetFloat', $result->getMessage());
380        return(0);
381    } else {
382        return(1);
383    }
384}
385
386function MetabaseQuerySetDecimal($database, $prepared_query, $parameter, $value)
387{
388    global $_MDB_databases;
389    $result = $_MDB_databases[$database]->setParamDecimal($prepared_query, $parameter, $value);
390    if (MDB::isError($result)) {
391        $_MDB_databases[$database]->setError('QuerySetDecimal', $result->getMessage());
392        return(0);
393    } else {
394        return(1);
395    }
396}
397
398function MetabaseAffectedRows($database, &$affected_rows)
399{
400    global $_MDB_databases;
401    $result = $_MDB_databases[$database]->affectedRows();
402    if (MDB::isError($result)) {
403        $_MDB_databases[$database]->setError('AffectedRows', $result->getMessage());
404        return(0);
405    } else {
406        $affected_rows = $result;
407        return(1);
408    }
409}
410
411function MetabaseFetchResult($database, $result, $row, $field)
412{
413    global $_MDB_databases;
414    $result = $_MDB_databases[$database]->fetch($result, $row, $field);
415    if (MDB::isError($result)) {
416        $_MDB_databases[$database]->setError('FetchResult', $result->getMessage());
417        return(0);
418    } else {
419        return($result);
420    }
421}
422
423function MetabaseFetchCLOBResult($database, $result, $row, $field)
424{
425    global $_MDB_databases;
426    $result = $_MDB_databases[$database]->fetchClob($result, $row, $field);
427    if (MDB::isError($result)) {
428        $_MDB_databases[$database]->setError('FetchCLOBResult', $result->getMessage());
429        return(0);
430    } else {
431        return($result);
432    }
433}
434
435function MetabaseFetchBLOBResult($database, $result, $row, $field)
436{
437    global $_MDB_databases;
438    $result = $_MDB_databases[$database]->fetchBlob($result, $row, $field);
439    if (MDB::isError($result)) {
440        $_MDB_databases[$database]->setError('FetchBLOBResult', $result->getMessage());
441        return(0);
442    } else {
443        return($result);
444    }
445}
446
447function MetabaseDestroyResultLOB($database, $lob)
448{
449    global $_MDB_databases;
450    $result = $_MDB_databases[$database]->_destroyResultLob($lob);
451    if (MDB::isError($result)) {
452        $_MDB_databases[$database]->setError('DestroyResultLOB', $result->getMessage());
453        return(0);
454    } else {
455        return(1);
456    }
457}
458
459function MetabaseEndOfResultLOB($database, $lob)
460{
461    global $_MDB_databases;
462    $result = $_MDB_databases[$database]->endOfResultLob($lob);
463    if (MDB::isError($result)) {
464        $_MDB_databases[$database]->setError('EndOfResultLOB', $result->getMessage());
465        return(0);
466    } else {
467        return($result);
468    }
469}
470
471function MetabaseReadResultLOB($database, $lob, &$data, $length)
472{
473    global $_MDB_databases;
474    $result = $_MDB_databases[$database]->_readResultLob($lob, $data, $length);
475    if (MDB::isError($result)) {
476        $_MDB_databases[$database]->setError('ReadResultLOB', $result->getMessage());
477        return(0);
478    } else {
479        return(1);
480    }
481}
482
483function MetabaseResultIsNull($database, $result, $row, $field)
484{
485    global $_MDB_databases;
486    $result = $_MDB_databases[$database]->resultIsNull($result, $row, $field);
487    if (MDB::isError($result)) {
488        $_MDB_databases[$database]->setError('ResultIsNull', $result->getMessage());
489        return(0);
490    } else {
491        return($result);
492    }
493}
494
495function MetabaseFetchDateResult($database, $result, $row, $field)
496{
497    global $_MDB_databases;
498    $result = $_MDB_databases[$database]->fetchDate($result, $row, $field);
499    if (MDB::isError($result)) {
500        $_MDB_databases[$database]->setError('FetchDateResult', $result->getMessage());
501        return(0);
502    } else {
503        return($result);
504    }
505}
506
507function MetabaseFetchTimestampResult($database, $result, $row, $field)
508{
509    global $_MDB_databases;
510    $result = $_MDB_databases[$database]->fetchTimestamp($result, $row, $field);
511    if (MDB::isError($result)) {
512        $_MDB_databases[$database]->setError('FetchTimestampResult', $result->getMessage());
513        return(0);
514    } else {
515        return($result);
516    }
517}
518
519function MetabaseFetchTimeResult($database, $result, $row, $field)
520{
521    global $_MDB_databases;
522    $result = $_MDB_databases[$database]->fetchTime($result, $row, $field);
523    if (MDB::isError($result)) {
524        $_MDB_databases[$database]->setError('FetchTimeResult', $result->getMessage());
525        return(0);
526    } else {
527        return($result);
528    }
529}
530
531function MetabaseFetchBooleanResult($database, $result, $row, $field)
532{
533    global $_MDB_databases;
534    $result = $_MDB_databases[$database]->fetchBoolean($result, $row, $field);
535    if (MDB::isError($result)) {
536        $_MDB_databases[$database]->setError('FetchBooleanResult', $result->getMessage());
537        return(0);
538    } else {
539        return($result);
540    }
541}
542
543function MetabaseFetchFloatResult($database, $result, $row, $field)
544{
545    global $_MDB_databases;
546    $result = $_MDB_databases[$database]->fetchFloat($result, $row, $field);
547    if (MDB::isError($result)) {
548        $_MDB_databases[$database]->setError('FetchFloatResult', $result->getMessage());
549        return(0);
550    } else {
551        return($result);
552    }
553}
554
555function MetabaseFetchDecimalResult($database, $result, $row, $field)
556{
557    global $_MDB_databases;
558    $result = $_MDB_databases[$database]->fetchDecimal($result, $row, $field);
559    if (MDB::isError($result)) {
560        $_MDB_databases[$database]->setError('FetchDecimalResult', $result->getMessage());
561        return(0);
562    } else {
563        return($result);
564    }
565}
566
567function MetabaseFetchResultField($database, $result, &$field)
568{
569    global $_MDB_databases;
570    $result = $_MDB_databases[$database]->fetchOne($result);
571    if (MDB::isError($result)) {
572        $_MDB_databases[$database]->setError('FetchResultField', $result->getMessage());
573        return(0);
574    } else {
575        $field = $result;
576        return(1);
577    }
578}
579
580function MetabaseFetchResultArray($database, $result, &$array, $row)
581{
582    global $_MDB_databases;
583    $result = $_MDB_databases[$database]->fetchInto($result, MDB_FETCHMODE_ORDERED, $row);
584    if (MDB::isError($result)) {
585        $_MDB_databases[$database]->setError('FetchResultArray', $result->getMessage());
586        return(0);
587    } else {
588        $array = $result;
589        return(1);
590    }
591}
592
593function MetabaseFetchResultRow($database, $result, &$row)
594{
595    global $_MDB_databases;
596    $result = $_MDB_databases[$database]->fetchRow($result);
597    if (MDB::isError($result)) {
598        $_MDB_databases[$database]->setError('FetchResultRow', $result->getMessage());
599        return(0);
600    } else {
601        $row = $result;
602        return(1);
603    }
604}
605
606function MetabaseFetchResultColumn($database, $result, &$column)
607{
608    global $_MDB_databases;
609    $result = $_MDB_databases[$database]->fetchCol($result);
610    if (MDB::isError($result)) {
611        $_MDB_databases[$database]->setError('FetchResultColumn', $result->getMessage());
612        return(0);
613    } else {
614        $column = $result;
615        return(1);
616    }
617}
618
619function MetabaseFetchResultAll($database, $result, &$all)
620{
621    global $_MDB_databases;
622    $result = $_MDB_databases[$database]->fetchAll($result);
623    if (MDB::isError($result)) {
624        $_MDB_databases[$database]->setError('FetchResultAll', $result->getMessage());
625        return(0);
626    } else {
627        $all = $result;
628        return(1);
629    }
630}
631
632function MetabaseNumberOfRows($database, $result)
633{
634    global $_MDB_databases;
635    $result = $_MDB_databases[$database]->numRows($result);
636    if (MDB::isError($result)) {
637        $_MDB_databases[$database]->setError('NumberOfRows', $result->getMessage());
638        return(0);
639    } else {
640       return($result);
641    }
642}
643
644function MetabaseNumberOfColumns($database, $result)
645{
646    global $_MDB_databases;
647    $result = $_MDB_databases[$database]->numCols($result);
648    if (MDB::isError($result)) {
649        $_MDB_databases[$database]->setError('NumberOfColumns', $result->getMessage());
650        return(0);
651    } else {
652        return($result);
653    }
654}
655
656function MetabaseGetColumnNames($database, $result, &$column_names)
657{
658    global $_MDB_databases;
659    $result = $_MDB_databases[$database]->getColumnNames($result);
660    if (MDB::isError($result)) {
661        $_MDB_databases[$database]->setError('GetColumnNames', $result->getMessage());
662        return(0);
663    } else {
664        $column_names = $result;
665        return(1);
666    }
667}
668
669function MetabaseSetResultTypes($database, $result, &$types)
670{
671    global $_MDB_databases;
672    $result = $_MDB_databases[$database]->setResultTypes($result, $types);
673    if (MDB::isError($result)) {
674        $_MDB_databases[$database]->setError('SetResultTypes', $result->getMessage());
675        return(0);
676    } else {
677        return(1);
678    }
679}
680
681function MetabaseFreeResult($database, $result)
682{
683    global $_MDB_databases;
684    $result = $_MDB_databases[$database]->freeResult($result);
685    if (MDB::isError($result)) {
686        $_MDB_databases[$database]->setError('FreeResult', $result->getMessage());
687        return(0);
688    } else {
689        return(1);
690    }
691}
692
693function MetabaseError($database)
694{
695    global $_MDB_databases;
696    $result = $_MDB_databases[$database]->error();
697    if (MDB::isError($result)) {
698        $_MDB_databases[$database]->setError('Error', $result->getMessage());
699        return(0);
700    } else {
701        return(1);
702    }
703}
704
705function MetabaseSetErrorHandler($database, $function)
706{
707    global $_MDB_databases;
708    $result = $_MDB_databases[$database]->setErrorHandler($function);
709    if (MDB::isError($result)) {
710        $_MDB_databases[$database]->setError('SetErrorHandler', $result->getMessage());
711        return(0);
712    } else {
713        return(1);
714    }
715}
716
717function MetabaseCreateDatabase($database, $name)
718{
719    global $_MDB_databases;
720    $result = $_MDB_databases[$database]->createDatabase($name);
721    if (MDB::isError($result)) {
722        $_MDB_databases[$database]->setError('CreateDatabase', $result->getMessage());
723        return(0);
724    } else {
725        return(1);
726    }
727}
728
729function MetabaseDropDatabase($database, $name)
730{
731    global $_MDB_databases;
732    $result = $_MDB_databases[$database]->dropDatabase($name);
733    if (MDB::isError($result)) {
734        $_MDB_databases[$database]->setError('DropDatabase', $result->getMessage());
735        return(0);
736    } else {
737        return(1);
738    }
739}
740
741function MetabaseSetDatabase($database, $name)
742{
743    global $_MDB_databases;
744    $result = $_MDB_databases[$database]->setDatabase($name);
745    if (MDB::isError($result)) {
746        $_MDB_databases[$database]->setError('SetDatabase', $result->getMessage());
747        return(0);
748    } else {
749        return($result);
750    }
751}
752
753function MetabaseGetIntegerFieldTypeDeclaration($database, $name, &$field)
754{
755    global $_MDB_databases;
756    $result = $_MDB_databases[$database]->getIntegerDeclaration($name, $field);
757    if (MDB::isError($result)) {
758        $_MDB_databases[$database]->setError('GetIntegerFieldTypeDeclaration', $result->getMessage());
759        return(0);
760    } else {
761        return(1);
762    }
763}
764
765function MetabaseGetTextFieldTypeDeclaration($database, $name, &$field)
766{
767    global $_MDB_databases;
768    $result = $_MDB_databases[$database]->getTextDeclaration($name, $field);
769    if (MDB::isError($result)) {
770        $_MDB_databases[$database]->setError('GetTextFieldTypeDeclaration', $result->getMessage());
771        return(0);
772    } else {
773        return(1);
774    }
775}
776
777function MetabaseGetCLOBFieldTypeDeclaration($database, $name, &$field)
778{
779    global $_MDB_databases;
780    $result = $_MDB_databases[$database]->getClobDeclaration($name, $field);
781    if (MDB::isError($result)) {
782        $_MDB_databases[$database]->setError('GetCLOBFieldTypeDeclaration', $result->getMessage());
783        return(0);
784    } else {
785        return(1);
786    }
787}
788
789function MetabaseGetBLOBFieldTypeDeclaration($database, $name, &$field)
790{
791    global $_MDB_databases;
792    $result = $_MDB_databases[$database]->getBlobDeclaration($name, $field);
793    if (MDB::isError($result)) {
794        $_MDB_databases[$database]->setError('GetBLOBFieldTypeDeclaration', $result->getMessage());
795        return(0);
796    } else {
797        return(1);
798    }
799}
800
801function MetabaseGetBooleanFieldTypeDeclaration($database, $name, &$field)
802{
803    global $_MDB_databases;
804    $result = $_MDB_databases[$database]->getBooleanDeclaration($name, $field);
805    if (MDB::isError($result)) {
806        $_MDB_databases[$database]->setError('GetBooleanFieldTypeDeclaration', $result->getMessage());
807        return(0);
808    } else {
809        return(1);
810    }
811}
812
813function MetabaseGetDateFieldTypeDeclaration($database, $name, &$field)
814{
815    global $_MDB_databases;
816    $result = $_MDB_databases[$database]->getDateDeclaration($name, $field);
817    if (MDB::isError($result)) {
818        $_MDB_databases[$database]->setError('GetDateFieldTypeDeclaration', $result->getMessage());
819        return(0);
820    } else {
821        return(1);
822    }
823}
824
825function MetabaseGetTimestampFieldTypeDeclaration($database, $name, &$field)
826{
827    global $_MDB_databases;
828    $result = $_MDB_databases[$database]->getTimestampDeclaration($name, $field);
829    if (MDB::isError($result)) {
830        $_MDB_databases[$database]->setError('GetTimestampFieldTypeDeclaration', $result->getMessage());
831        return(0);
832    } else {
833        return(1);
834    }
835}
836
837function MetabaseGetTimeFieldTypeDeclaration($database, $name, &$field)
838{
839    global $_MDB_databases;
840    $result = $_MDB_databases[$database]->getTimeDeclaration($name, $field);
841    if (MDB::isError($result)) {
842        $_MDB_databases[$database]->setError('GetTimeFieldTypeDeclaration', $result->getMessage());
843        return(0);
844    } else {
845        return(1);
846    }
847}
848
849function MetabaseGetFloatFieldTypeDeclaration($database, $name, &$field)
850{
851    global $_MDB_databases;
852    $result = $_MDB_databases[$database]->getFloatDeclaration($name, $field);
853    if (MDB::isError($result)) {
854        $_MDB_databases[$database]->setError('GetFloatFieldTypeDeclaration', $result->getMessage());
855        return(0);
856    } else {
857        return(1);
858    }
859}
860
861function MetabaseGetDecimalFieldTypeDeclaration($database, $name, &$field)
862{
863    global $_MDB_databases;
864    $result = $_MDB_databases[$database]->getDecimalDeclaration($name, $field);
865    if (MDB::isError($result)) {
866        $_MDB_databases[$database]->setError('GetDecimalFieldTypeDeclaration', $result->getMessage());
867        return(0);
868    } else {
869        return(1);
870    }
871}
872
873function MetabaseGetTextFieldValue($database, $value)
874{
875    global $_MDB_databases;
876    $result = $_MDB_databases[$database]->getTextValue($value);
877    if (MDB::isError($result)) {
878        $_MDB_databases[$database]->setError('GetTextFieldValue', $result->getMessage());
879        return(0);
880    } else {
881        return($result);
882    }
883}
884
885function MetabaseGetBooleanFieldValue($database, $value)
886{
887    global $_MDB_databases;
888    $result = $_MDB_databases[$database]->getBooleanValue($value);
889    if (MDB::isError($result)) {
890        $_MDB_databases[$database]->setError('GetBooleanFieldValue', $result->getMessage());
891        return(0);
892    } else {
893        return($result);
894    }
895}
896
897function MetabaseGetDateFieldValue($database, $value)
898{
899    global $_MDB_databases;
900    $result = $_MDB_databases[$database]->getDateValue($value);
901    if (MDB::isError($result)) {
902        $_MDB_databases[$database]->setError('GetDateFieldValue', $result->getMessage());
903        return(0);
904    } else {
905        return($result);
906    }
907}
908
909function MetabaseGetTimestampFieldValue($database, $value)
910{
911    global $_MDB_databases;
912    $result = $_MDB_databases[$database]->getTimestampValue($value);
913    if (MDB::isError($result)) {
914        $_MDB_databases[$database]->setError('GetTimestampFieldValue', $result->getMessage());
915        return(0);
916    } else {
917        return($result);
918    }
919}
920
921function MetabaseGetTimeFieldValue($database, $value)
922{
923    global $_MDB_databases;
924    $result = $_MDB_databases[$database]->getTimeValue($value);
925    if (MDB::isError($result)) {
926        $_MDB_databases[$database]->setError('GetTimeFieldValue', $result->getMessage());
927        return(0);
928    } else {
929        return($result);
930    }
931}
932
933function MetabaseGetFloatFieldValue($database, $value)
934{
935    global $_MDB_databases;
936    $result = $_MDB_databases[$database]->getFloatValue($value);
937    if (MDB::isError($result)) {
938        $_MDB_databases[$database]->setError('GetFloatFieldValue', $result->getMessage());
939        return(0);
940    } else {
941        return($result);
942    }
943}
944
945function MetabaseGetDecimalFieldValue($database, $value)
946{
947    global $_MDB_databases;
948    $result = $_MDB_databases[$database]->getDecimalValue($value);
949    if (MDB::isError($result)) {
950        $_MDB_databases[$database]->setError('GetDecimalFieldValue', $result->getMessage());
951        return(0);
952    } else {
953        return($result);
954    }
955}
956
957function MetabaseSupport($database, $feature)
958{
959    global $_MDB_databases;
960    $result = $_MDB_databases[$database]->support($feature);
961    if (MDB::isError($result)) {
962        $_MDB_databases[$database]->setError('Support', $result->getMessage());
963        return(0);
964    } else {
965       return($result);
966    }
967}
968
969function MetabaseCreateTable($database, $name, &$fields)
970{
971    global $_MDB_databases;
972    $result = $_MDB_databases[$database]->createTable($name, $fields);
973    if (MDB::isError($result)) {
974        $_MDB_databases[$database]->setError('CreateTable', $result->getMessage());
975        return(0);
976    } else {
977        return(1);
978    }
979}
980
981function MetabaseDropTable($database, $name)
982{
983    global $_MDB_databases;
984    $result = $_MDB_databases[$database]->dropTable($name);
985    if (MDB::isError($result)) {
986        $_MDB_databases[$database]->setError('DropTable', $result->getMessage());
987        return(0);
988    } else {
989        return(1);
990    }
991}
992
993function MetabaseAlterTable($database, $name, &$changes, $check = 0)
994{
995    global $_MDB_databases;
996    $result = $_MDB_databases[$database]->alterTable($name, $changes, $check);
997    if (MDB::isError($result)) {
998        $_MDB_databases[$database]->setError('AlterTable', $result->getMessage());
999        return(0);
1000    } else {
1001        return(1);
1002    }
1003}
1004
1005function MetabaseListTables($database, &$tables)
1006{
1007    global $_MDB_databases;
1008    $result = $_MDB_databases[$database]->listTables();
1009    if (MDB::isError($result)) {
1010        $_MDB_databases[$database]->setError('ListTables', $result->getMessage());
1011        return(0);
1012    } else {
1013        $tables = $result;
1014        return(1);
1015    }
1016}
1017
1018function MetabaseListTableFields($database, $table, &$fields)
1019{
1020    global $_MDB_databases;
1021    $result = $_MDB_databases[$database]->listTableFields($table);
1022    if (MDB::isError($result)) {
1023        $_MDB_databases[$database]->setError('ListTableFields', $result->getMessage());
1024        return(0);
1025    } else {
1026        $fields = $result;
1027        return(1);
1028    }
1029}
1030
1031function MetabaseGetTableFieldDefinition($database, $table, $field, &$definition)
1032{
1033    global $_MDB_databases;
1034    $result = $_MDB_databases[$database]->getTableFieldDefinition($table, $field);
1035    if (MDB::isError($result)) {
1036        $_MDB_databases[$database]->setError('GetTableFieldDefinition', $result->getMessage());
1037        return(0);
1038    } else {
1039        $definition = $result[0];
1040        return(1);
1041    }
1042}
1043
1044function MetabaseCreateSequence($database, $name, $start)
1045{
1046    global $_MDB_databases;
1047    $result = $_MDB_databases[$database]->createSequence($name, $start);
1048    if (MDB::isError($result)) {
1049        $_MDB_databases[$database]->setError('CreateSequence', $result->getMessage());
1050        return(0);
1051    } else {
1052        return(1);
1053    }
1054}
1055
1056function MetabaseDropSequence($database, $name)
1057{
1058    global $_MDB_databases;
1059    $result = $_MDB_databases[$database]->dropSequence($name);
1060    if (MDB::isError($result)) {
1061        $_MDB_databases[$database]->setError('DropSequence', $result->getMessage());
1062        return(0);
1063    } else {
1064        return(1);
1065    }
1066}
1067
1068function MetabaseGetSequenceNextValue($database, $name, &$value)
1069{
1070    global $_MDB_databases;
1071    $result = $_MDB_databases[$database]->nextId($name, FALSE);
1072    if (MDB::isError($result)) {
1073        $_MDB_databases[$database]->setError('GetSequenceNextValue', $result->getMessage());
1074        return(0);
1075    } else {
1076        $value = $result;
1077        return(1);
1078    }
1079}
1080
1081function MetabaseGetSequenceCurrentValue($database, $name, &$value)
1082{
1083    global $_MDB_databases;
1084    $result = $_MDB_databases[$database]->currId($name);
1085    if (MDB::isError($result)) {
1086        $_MDB_databases[$database]->setError('GetSequenceCurrentValue', $result->getMessage());
1087        return(0);
1088    } else {
1089        $value = $result;
1090        return(1);
1091    }
1092}
1093
1094function MetabaseListSequences($database, &$sequences)
1095{
1096    global $_MDB_databases;
1097    $result = $_MDB_databases[$database]->listSequences();
1098    if (MDB::isError($result)) {
1099        $_MDB_databases[$database]->setError('ListSequences', $result->getMessage());
1100        return(0);
1101    } else {
1102        $sequences = $result;
1103        return(1);
1104    }
1105}
1106
1107function MetabaseGetSequenceDefinition($database, $sequence, &$definition)
1108{
1109    global $_MDB_databases;
1110    $result = $_MDB_databases[$database]->getSequenceDefinition($sequence);
1111    if (MDB::isError($result)) {
1112        $_MDB_databases[$database]->setError('GetSequenceDefinition', $result->getMessage());
1113        return(0);
1114    } else {
1115        $definition = $result;
1116        return(1);
1117    }
1118}
1119
1120function MetabaseAutoCommitTransactions($database, $auto_commit)
1121{
1122    global $_MDB_databases;
1123    $result = $_MDB_databases[$database]->autoCommit($auto_commit);
1124    if (MDB::isError($result)) {
1125        $_MDB_databases[$database]->setError('AutoCommitTransactions', $result->getMessage());
1126        return(0);
1127    } else {
1128        return(1);
1129    }
1130}
1131
1132function MetabaseCommitTransaction($database)
1133{
1134    global $_MDB_databases;
1135    $result = $_MDB_databases[$database]->commit();
1136    if (MDB::isError($result)) {
1137        $_MDB_databases[$database]->setError('CommitTransaction', $result->getMessage());
1138        return(0);
1139    } else {
1140        return(1);
1141    }
1142}
1143
1144function MetabaseRollbackTransaction($database)
1145{
1146    global $_MDB_databases;
1147    $result = $_MDB_databases[$database]->rollback();
1148    if (MDB::isError($result)) {
1149        $_MDB_databases[$database]->setError('RollbackTransaction', $result->getMessage());
1150        return(0);
1151    } else {
1152        return($result);
1153    }
1154}
1155
1156function MetabaseCreateIndex($database, $table, $name, $definition)
1157{
1158    global $_MDB_databases;
1159    $result = $_MDB_databases[$database]->createIndex($table, $name, $definition);
1160    if (MDB::isError($result)) {
1161        $_MDB_databases[$database]->setError('CreateIndex', $result->getMessage());
1162        return(0);
1163    } else {
1164        return(1);
1165    }
1166}
1167
1168function MetabaseDropIndex($database, $table, $name)
1169{
1170    global $_MDB_databases;
1171    $result = $_MDB_databases[$database]->dropIndex($table, $name);
1172    if (MDB::isError($result)) {
1173        $_MDB_databases[$database]->setError('DropIndex', $result->getMessage());
1174        return(0);
1175    } else {
1176        return(1);
1177    }
1178}
1179
1180function MetabaseListTableIndex($database, $table, &$index)
1181{
1182    global $_MDB_databases;
1183    $result = $_MDB_databases[$database]->listTableIndex($table);
1184    if (MDB::isError($result)) {
1185        $_MDB_databases[$database]->setError('ListTableIndex', $result->getMessage());
1186        return(0);
1187    } else {
1188        $index = $result;
1189        return(1);
1190    }
1191}
1192
1193function MetabaseGetTableIndexDefinition($database, $table, $index, &$definition)
1194{
1195    global $_MDB_databases;
1196    $result = $_MDB_databases[$database]->getTableIndexDefinition($table, $index);
1197    if (MDB::isError($result)) {
1198        $_MDB_databases[$database]->setError('GetTableIndexDefinition', $result->getMessage());
1199        return(0);
1200    } else {
1201        $definition = $result;
1202        return(1);
1203    }
1204}
1205
1206function MetabaseNow()
1207{
1208    return(MDB_Date::mdbNow());
1209}
1210
1211function MetabaseToday()
1212{
1213    return(MDB_Date::mdbToday());
1214}
1215
1216function MetabaseTime()
1217{
1218    return(MDB_Date::mdbTime());
1219}
1220
1221function MetabaseSetSelectedRowRange($database, $first, $limit)
1222{
1223    global $_MDB_databases;
1224    $result = $_MDB_databases[$database]->setSelectedRowRange($first, $limit);
1225    if (MDB::isError($result)) {
1226        $_MDB_databases[$database]->setError('SetSelectedRowRange', $result->getMessage());
1227        return(0);
1228    } else {
1229        return(1);
1230    }
1231}
1232
1233function MetabaseEndOfResult($database, $result)
1234{
1235    global $_MDB_databases;
1236    $result = $_MDB_databases[$database]->endOfResult($result);
1237    if (MDB::isError($result)) {
1238        $_MDB_databases[$database]->setError('EndOfResult', $result->getMessage());
1239        return(0);
1240    } else {
1241       return($result);
1242    }
1243}
1244
1245function MetabaseCaptureDebugOutput($database, $capture)
1246{
1247    global $_MDB_databases;
1248    $result = $_MDB_databases[$database]->captureDebugOutput($capture);
1249    if (MDB::isError($result)) {
1250        $_MDB_databases[$database]->setError('CaptureDebugOutput', $result->getMessage());
1251        return(0);
1252    } else {
1253        return(1);
1254    }
1255}
1256
1257function MetabaseDebugOutput($database)
1258{
1259    global $_MDB_databases;
1260    $result = $_MDB_databases[$database]->debugOutput();
1261    if (MDB::isError($result)) {
1262        $_MDB_databases[$database]->setError('DebugOutput', $result->getMessage());
1263        return(0);
1264    } else {
1265        return($result);
1266    }
1267}
1268
1269function MetabaseDebug($database, $message)
1270{
1271    global $_MDB_databases;
1272    $result = $_MDB_databases[$database]->debug($message);
1273    if (MDB::isError($result)) {
1274        $_MDB_databases[$database]->setError('Debug', $result->getMessage());
1275        return(0);
1276    } else {
1277        return(1);
1278    }
1279}
1280
1281function MetabaseShutdownTransactions()
1282{
1283    _shutdownTransactions();
1284}
1285
1286function MetabaseDefaultDebugOutput($database, $message)
1287{
1288    global $_MDB_databases;
1289    $result = $_MDB_databases[$database]->defaultDebugOutput($_MDB_databases[$database], $message);
1290    if (MDB::isError($result)) {
1291        $_MDB_databases[$database]->setError('DefaultDebugOutput', $result->getMessage());
1292        return(0);
1293    } else {
1294        return(1);
1295    }
1296}
1297
1298function MetabaseCreateLOB(&$arguments, &$lob)
1299{
1300    global $_MDB_databases;
1301    $args = $arguments;
1302    $args['Database'] = $_MDB_databases[$arguments['Database']];
1303    $result = $_MDB_databases[$arguments['Database']]->createLob($args);
1304    $args['Database'] = $arguments['Database']
1305    ;
1306    if (MDB::isError($result)) {
1307        global $lob_error;
1308        $lob_error = $result->getMessage();
1309        return(0);
1310    } else {
1311        $lob = $result;
1312        return(1);
1313    }
1314}
1315
1316function MetabaseDestroyLOB($lob)
1317{
1318    global $_MDB_lobs;
1319    $result = $_MDB_lobs[$lob]->database->destroyLob($lob);
1320    if (MDB::isError($result)) {
1321        global $lob_error;
1322        $lob_error = $result->getMessage();
1323        return(0);
1324    } else {
1325        return(1);
1326    }
1327}
1328
1329function MetabaseEndOfLOB($lob)
1330{
1331    global $_MDB_lobs;
1332    $result = $_MDB_lobs[$lob]->database->endOfLob($lob);
1333    if (MDB::isError($result)) {
1334        global $lob_error;
1335        $lob_error = $result->getMessage();
1336        return(0);
1337    } else {
1338        return($result);
1339    }
1340}
1341
1342function MetabaseReadLOB($lob, &$data, $length)
1343{
1344    global $_MDB_lobs;
1345    $result = $_MDB_lobs[$lob]->database->readLob($lob, $data, $length);
1346    if (MDB::isError($result)) {
1347        global $lob_error;
1348        $lob_error = $result->getMessage();
1349        return(0);
1350    } else {
1351        return($result);
1352    }
1353}
1354
1355function MetabaseLOBError($lob)
1356{
1357    global $lob_error;
1358    return($lob_error);
1359}
1360
1361class metabase_manager_class
1362{
1363    var $MDB_manager_object;
1364
1365    var $fail_on_invalid_names = 1;
1366    var $error = '';
1367    var $warnings = array();
1368    var $database = 0;
1369    var $database_definition = array(
1370        'name' => '',
1371        'create' => 0,
1372        'TABLES' => array()
1373    );
1374
1375    function metabase_manager_class()
1376    {
1377        $this->MDB_manager_object =& new MDB_Manager;
1378        $this->MDB_manager_object->fail_on_invalid_names =& $this->fail_on_invalid_names;
1379        $this->MDB_manager_object->error =& $this->error;
1380        $this->MDB_manager_object->warnings =& $this->warnings;
1381        $this->MDB_manager_object->database_definition =& $this->database_definition;
1382    }
1383
1384    function SetupDatabase(&$arguments)
1385    {
1386        _convertArguments($arguments, $dsninfo, $options);
1387
1388        $result = $this->MDB_manager_object->connect($dsninfo, $options);
1389        if (MDB::isError($result)) {
1390            return($result->getMessage());
1391        }
1392        $this->database = $this->MDB_manager_object->database->database;
1393        return(1);
1394    }
1395
1396    function CloseSetup()
1397    {
1398        $result = $this->MDB_manager_object->disconnect();
1399        if (MDB::isError($result)) {
1400            return(0);
1401        } else {
1402            return(1);
1403        }
1404    }
1405
1406    function GetField(&$field, $field_name, $declaration, &$query)
1407    {
1408        if($declaration) {
1409            $result = $this->MDB_manager_object->database->getFieldDeclaration($field, $field_name, $declaration);
1410        } else {
1411            $result = $field_name;
1412        }
1413        if (MDB::isError($result)) {
1414            return(0);
1415        } else {
1416            $query = $result;
1417            return(1);
1418        }
1419    }
1420
1421    function GetFieldList($fields, $declaration, &$query_fields)
1422    {
1423        if($declaration) {
1424            $result = $this->MDB_manager_object->database->getFieldDeclarationList($fields);
1425        } else {
1426            for(reset($fields), $i = 0;
1427                $field_number < count($fields);
1428                $i++, next($fields))
1429            {
1430                if ($i > 0) {
1431                    $query_fields .= ', ';
1432                }
1433                $result .= key($fields);
1434            }
1435        }
1436        if (MDB::isError($result)) {
1437            return(0);
1438        } else {
1439            $query_fields = $result;
1440            return(1);
1441        }
1442    }
1443
1444    function GetFields($table, &$fields)
1445    {
1446        $result = $this->MDB_manager_object->database->getFieldDeclarationList($this->database_definition['TABLES'][$table]['FIELDS']);
1447        if (MDB::isError($result)) {
1448            return(0);
1449        } else {
1450            $fields = $result;
1451            return(1);
1452        }
1453    }
1454
1455    function CreateTable($table_name, $table)
1456    {
1457        $result = $this->MDB_manager_object->_createTable($table_name, $table);
1458        if (MDB::isError($result)) {
1459            return(0);
1460        } else {
1461            return(1);
1462        }
1463    }
1464
1465    function DropTable($table_name)
1466    {
1467        $result = $this->MDB_manager_object->_dropTable($table_name);
1468        if (MDB::isError($result)) {
1469            return(0);
1470        } else {
1471            return(1);
1472        }
1473    }
1474
1475    function CreateSequence($sequence_name, $sequence, $created_on_table)
1476    {
1477        $result = $this->MDB_manager_object->createSequence($sequence_name, $sequence, $created_on_table);
1478        if (MDB::isError($result)) {
1479            return(0);
1480        } else {
1481            return(1);
1482        }
1483    }
1484
1485    function DropSequence($sequence_name)
1486    {
1487        $result = $this->MDB_manager_object->_dropSequence($sequence_name);
1488        if (MDB::isError($result)) {
1489            return(0);
1490        } else {
1491            return(1);
1492        }
1493    }
1494
1495    function CreateDatabase()
1496    {
1497        $result = $this->MDB_manager_object->_createDatabase();
1498        if (MDB::isError($result)) {
1499            return(0);
1500        } else {
1501            return(1);
1502        }
1503    }
1504
1505    function AddDefinitionChange(&$changes, $definition, $item, $change)
1506    {
1507        $result = $this->MDB_manager_object->_addDefinitionChange($changes, $definition, $item, $change);
1508        if (MDB::isError($result)) {
1509            return(0);
1510        } else {
1511            return(1);
1512        }
1513    }
1514
1515    function CompareDefinitions(&$previous_definition, &$changes)
1516    {
1517        $result = $this->MDB_manager_object->_compareDefinitions($previous_definition);
1518        if (MDB::isError($result)) {
1519            return(0);
1520        } else {
1521            $changes = $result;
1522            return(1);
1523        }
1524    }
1525
1526    function AlterDatabase(&$previous_definition, &$changes)
1527    {
1528        $result = $this->MDB_manager_object->_alterDatabase($previous_definition, $changes);
1529        if (MDB::isError($result)) {
1530            return(0);
1531        } else {
1532            return(1);
1533        }
1534    }
1535
1536    function EscapeSpecialCharacters($string)
1537    {
1538        $result = $this->MDB_manager_object->_escapeSpecialCharacters($string);
1539        if (MDB::isError($result)) {
1540            return(0);
1541        } else {
1542            return($result);
1543        }
1544    }
1545
1546    function DumpSequence($sequence_name, $output, $eol, $dump_definition)
1547    {
1548        $result = $this->MDB_manager_object->_dumpSequence($sequence_name, $output, $eol, $dump_definition);
1549        if (MDB::isError($result)) {
1550            return(0);
1551        } else {
1552            return(1);
1553        }
1554    }
1555
1556    function DumpDatabase($arguments)
1557    {
1558        $result = $this->MDB_manager_object->dumpDatabase($arguments);
1559        if (MDB::isError($result)) {
1560            return(0);
1561        } else {
1562            return(1);
1563        }
1564    }
1565
1566    function ParseDatabaseDefinitionFile($input_file, &$database_definition, &$variables, $fail_on_invalid_names = 1)
1567    {
1568        $result = $this->MDB_manager_object->parseDatabaseDefinitionFile($input_file, $variables, $fail_on_invalid_names);
1569        if (MDB::isError($result)) {
1570            return(0);
1571        } else {
1572            $database_definition = $result;
1573            return(1);
1574        }
1575    }
1576
1577    function DumpDatabaseChanges(&$changes)
1578    {
1579        $result = $this->MDB_manager_object->_debugDatabaseChanges($changes);
1580        if (MDB::isError($result)) {
1581            return(0);
1582        } else {
1583            return(1);
1584        }
1585    }
1586
1587    function UpdateDatabase($current_schema_file, $previous_schema_file, &$arguments, &$variables)
1588    {
1589        _convertArguments($arguments, $dsninfo, $options);
1590
1591        $result = $this->MDB_manager_object->connect($dsninfo, $options);
1592        if (MDB::isError($result)) {
1593            return($result);
1594        }
1595
1596        $result = $this->MDB_manager_object->updateDatabase($current_schema_file, $previous_schema_file, $variables);
1597        if (MDB::isError($result)) {
1598            return($result->getMessage());
1599        }
1600        $this->database = $this->MDB_manager_object->database->database;
1601        return(1);
1602    }
1603
1604    function DumpDatabaseContents($schema_file, &$setup_arguments, &$dump_arguments, &$variables)
1605    {
1606        $result = $this->MDB_manager_object->_dumpDatabaseContents($schema_file, $setup_arguments, $dump_arguments, $variables);
1607        if (MDB::isError($result)) {
1608            return(0);
1609        } else {
1610            $database_definition = $result;
1611            return($result);
1612        }
1613    }
1614
1615    function GetDefinitionFromDatabase()
1616    {
1617        $result = $this->MDB_manager_object->getDefinitionFromDatabase();
1618        if (MDB::isError($result)) {
1619            return(0);
1620        } else {
1621            return(1);
1622        }
1623    }
1624};
1625?>
1626