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