?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
$config to phpbb::$config
[phpbb.git] / phpBB / modules / acp / acp_database.php
blob14e38bc6978ac0cca713ba1f193d5c996275cab8
1 <?php
2 /**
3 *
4 * @package acp
5 * @version $Id$
6 * @copyright (c) 2005 phpBB Group
7 * @license http://opensource.org/licenses/gpl-license.php GNU Public License
8 *
9 */
10
11 /**
12 * @ignore
13 */
14 if (!defined('IN_PHPBB'))
15 {
16 exit;
17 }
18
19 /**
20 * @package acp
21 */
22 class acp_database
23 {
24 var $u_action;
25
26 function main($id, $mode)
27 {
28 global $db, $user, $auth, $template, $table_prefix;
29
30 $user->add_lang('acp/database');
31
32 $this->tpl_name = 'acp_database';
33 $this->page_title = 'ACP_DATABASE';
34
35 $action = request_var('action', '');
36 $submit = phpbb_request::is_set_post('submit');
37
38 $template->assign_vars(array(
39 'MODE' => $mode
40 ));
41
42 switch ($mode)
43 {
44 case 'backup':
45
46 $this->page_title = 'ACP_BACKUP';
47
48 switch ($action)
49 {
50 case 'download':
51 $type = request_var('type', '');
52 $table = request_var('table', array(''));
53 $format = request_var('method', '');
54 $where = request_var('where', '');
55
56 if (!sizeof($table))
57 {
58 trigger_error($user->lang['TABLE_SELECT_ERROR'] . adm_back_link($this->u_action), E_USER_WARNING);
59 }
60
61 $store = $download = $structure = $schema_data = false;
62
63 if ($where == 'store_and_download' || $where == 'store')
64 {
65 $store = true;
66 }
67
68 if ($where == 'store_and_download' || $where == 'download')
69 {
70 $download = true;
71 }
72
73 if ($type == 'full' || $type == 'structure')
74 {
75 $structure = true;
76 }
77
78 if ($type == 'full' || $type == 'data')
79 {
80 $schema_data = true;
81 }
82
83 @set_time_limit(1200);
84
85 $time = time();
86
87 $filename = 'backup_' . $time . '_' . unique_id();
88 switch ($db->dbms_type)
89 {
90 case 'mysql':
91 $extractor = new mysql_extractor($download, $store, $format, $filename, $time);
92 break;
93
94 case 'sqlite':
95 $extractor = new sqlite_extractor($download, $store, $format, $filename, $time);
96 break;
97
98 case 'postgres':
99 $extractor = new postgres_extractor($download, $store, $format, $filename, $time);
100 break;
101
102 case 'oracle':
103 $extractor = new oracle_extractor($download, $store, $format, $filename, $time);
104 break;
105
106 case 'mssql':
107 $extractor = new mssql_extractor($download, $store, $format, $filename, $time);
108 break;
109
110 case 'firebird':
111 $extractor = new firebird_extractor($download, $store, $format, $filename, $time);
112 break;
113
114 case 'db2':
115 $extractor = new db2_extractor($download, $store, $format, $filename, $time);
116 break;
117 }
118
119 $extractor->write_start($table_prefix);
120
121 foreach ($table as $table_name)
122 {
123 // Get the table structure
124 if ($structure)
125 {
126 $extractor->write_table($table_name);
127 }
128 else
129 {
130 // We might wanna empty out all that junk :D
131 switch ($db->dbms_type)
132 {
133 case 'sqlite':
134 case 'firebird':
135 case 'db2':
136 $extractor->flush('DELETE FROM ' . $table_name . ";\n");
137 break;
138
139 case 'mssql':
140 $extractor->flush('TRUNCATE TABLE ' . $table_name . "GO\n");
141 break;
142
143 case 'oracle':
144 $extractor->flush('TRUNCATE TABLE ' . $table_name . "\\\n");
145 break;
146
147 default:
148 $extractor->flush('TRUNCATE TABLE ' . $table_name . ";\n");
149 break;
150 }
151 }
152
153 // Data
154 if ($schema_data)
155 {
156 $extractor->write_data($table_name);
157 }
158 }
159
160 $extractor->write_end();
161
162 add_log('admin', 'LOG_DB_BACKUP');
163
164 if ($download == true)
165 {
166 exit;
167 }
168
169 trigger_error($user->lang['BACKUP_SUCCESS'] . adm_back_link($this->u_action));
170 break;
171
172 default:
173 include(PHPBB_ROOT_PATH . 'includes/functions_install.' . PHP_EXT);
174 $tables = get_tables($db);
175 asort($tables);
176 foreach ($tables as $table_name)
177 {
178 if (strlen($table_prefix) === 0 || stripos($table_name, $table_prefix) === 0)
179 {
180 $template->assign_block_vars('tables', array(
181 'TABLE' => $table_name
182 ));
183 }
184 }
185 unset($tables);
186
187 $template->assign_vars(array(
188 'U_ACTION' => $this->u_action . '&amp;action=download'
189 ));
190
191 $available_methods = array('gzip' => 'zlib', 'bzip2' => 'bz2');
192
193 foreach ($available_methods as $type => $module)
194 {
195 if (!@extension_loaded($module))
196 {
197 continue;
198 }
199
200 $template->assign_block_vars('methods', array(
201 'TYPE' => $type
202 ));
203 }
204
205 $template->assign_block_vars('methods', array(
206 'TYPE' => 'text'
207 ));
208 break;
209 }
210 break;
211
212 case 'restore':
213
214 $this->page_title = 'ACP_RESTORE';
215
216 switch ($action)
217 {
218 case 'submit':
219 $delete = request_var('delete', '');
220 $file = request_var('file', '');
221
222 if (!preg_match('#^backup_\d{10,}_[a-z\d]{16}\.(sql(?:\.(?:gz|bz2))?)$#', $file, $matches))
223 {
224 trigger_error($user->lang['BACKUP_INVALID'] . adm_back_link($this->u_action), E_USER_WARNING);
225 }
226
227 $file_name = PHPBB_ROOT_PATH . 'store/' . $matches[0];
228
229 if (!file_exists($file_name) || !is_readable($file_name))
230 {
231 trigger_error($user->lang['BACKUP_INVALID'] . adm_back_link($this->u_action), E_USER_WARNING);
232 }
233
234 if ($delete)
235 {
236 if (confirm_box(true))
237 {
238 unlink($file_name);
239 add_log('admin', 'LOG_DB_DELETE');
240 trigger_error($user->lang['BACKUP_DELETE'] . adm_back_link($this->u_action));
241 }
242 else
243 {
244 confirm_box(false, $user->lang['DELETE_SELECTED_BACKUP'], build_hidden_fields(array('delete' => $delete, 'file' => $file)));
245 }
246 }
247 else
248 {
249 $download = request_var('download', '');
250
251 if ($download)
252 {
253 $name = $matches[0];
254
255 switch ($matches[1])
256 {
257 case 'sql':
258 $mimetype = 'text/x-sql';
259 break;
260 case 'sql.bz2':
261 $mimetype = 'application/x-bzip2';
262 break;
263 case 'sql.gz':
264 $mimetype = 'application/x-gzip';
265 break;
266 }
267
268 header('Pragma: no-cache');
269 header("Content-Type: $mimetype; name=\"$name\"");
270 header("Content-disposition: attachment; filename=$name");
271
272 @set_time_limit(0);
273
274 $fp = @fopen($file_name, 'rb');
275
276 if ($fp !== false)
277 {
278 while (!feof($fp))
279 {
280 echo fread($fp, 8192);
281 }
282 fclose($fp);
283 }
284
285 flush();
286 exit;
287 }
288
289 switch ($matches[1])
290 {
291 case 'sql':
292 $fp = fopen($file_name, 'rb');
293 $read = 'fread';
294 $seek = 'fseek';
295 $eof = 'feof';
296 $close = 'fclose';
297 $fgetd = 'fgetd';
298 break;
299
300 case 'sql.bz2':
301 $fp = bzopen($file_name, 'r');
302 $read = 'bzread';
303 $seek = '';
304 $eof = 'feof';
305 $close = 'bzclose';
306 $fgetd = 'fgetd_seekless';
307 break;
308
309 case 'sql.gz':
310 $fp = gzopen($file_name, 'rb');
311 $read = 'gzread';
312 $seek = 'gzseek';
313 $eof = 'gzeof';
314 $close = 'gzclose';
315 $fgetd = 'fgetd';
316 break;
317 }
318
319 switch ($db->dbms_type)
320 {
321 case 'mysql':
322 case 'sqlite':
323 case 'db2':
324 while (($sql = $fgetd($fp, ";\n", $read, $seek, $eof)) !== false)
325 {
326 $db->sql_query($sql);
327 }
328 break;
329
330 case 'firebird':
331 $delim = ";\n";
332 while (($sql = $fgetd($fp, $delim, $read, $seek, $eof)) !== false)
333 {
334 $query = trim($sql);
335 if (substr($query, 0, 8) === 'SET TERM')
336 {
337 $delim = $query[9] . "\n";
338 continue;
339 }
340 $db->sql_query($query);
341 }
342 break;
343
344 case 'postgres':
345 $delim = ";\n";
346 while (($sql = $fgetd($fp, $delim, $read, $seek, $eof)) !== false)
347 {
348 $query = trim($sql);
349
350 if (substr($query, 0, 13) == 'CREATE DOMAIN')
351 {
352 list(, , $domain) = explode(' ', $query);
353 $sql = "SELECT domain_name
354 FROM information_schema.domains
355 WHERE domain_name = '$domain';";
356 $result = $db->sql_query($sql);
357 if (!$db->sql_fetchrow($result))
358 {
359 $db->sql_query($query);
360 }
361 $db->sql_freeresult($result);
362 }
363 else
364 {
365 $db->sql_query($query);
366 }
367
368 if (substr($query, 0, 4) == 'COPY')
369 {
370 while (($sub = $fgetd($fp, "\n", $read, $seek, $eof)) !== '\.')
371 {
372 if ($sub === false)
373 {
374 trigger_error($user->lang['RESTORE_FAILURE'] . adm_back_link($this->u_action), E_USER_WARNING);
375 }
376 pg_put_line($db->db_connect_id, $sub . "\n");
377 }
378 pg_put_line($db->db_connect_id, "\\.\n");
379 pg_end_copy($db->db_connect_id);
380 }
381 }
382 break;
383
384 case 'oracle':
385 while (($sql = $fgetd($fp, "/\n", $read, $seek, $eof)) !== false)
386 {
387 $db->sql_query($sql);
388 }
389 break;
390
391 case 'mssql':
392 while (($sql = $fgetd($fp, "GO\n", $read, $seek, $eof)) !== false)
393 {
394 $db->sql_query($sql);
395 }
396 break;
397 }
398
399 $close($fp);
400
401 // Purge the cache due to updated data
402 phpbb::$acm->purge();
403
404 add_log('admin', 'LOG_DB_RESTORE');
405 trigger_error($user->lang['RESTORE_SUCCESS'] . adm_back_link($this->u_action));
406 break;
407 }
408
409 default:
410 $methods = array('sql');
411 $available_methods = array('sql.gz' => 'zlib', 'sql.bz2' => 'bz2');
412
413 foreach ($available_methods as $type => $module)
414 {
415 if (!@extension_loaded($module))
416 {
417 continue;
418 }
419 $methods[] = $type;
420 }
421
422 $dir = PHPBB_ROOT_PATH . 'store/';
423 $dh = @opendir($dir);
424
425 if ($dh)
426 {
427 while (($file = readdir($dh)) !== false)
428 {
429 if (preg_match('#^backup_(\d{10,})_[a-z\d]{16}\.(sql(?:\.(?:gz|bz2))?)$#', $file, $matches))
430 {
431 $supported = in_array($matches[2], $methods);
432
433 if ($supported == 'true')
434 {
435 $template->assign_block_vars('files', array(
436 'FILE' => $file,
437 'NAME' => gmdate("d-m-Y H:i:s", $matches[1]),
438 'SUPPORTED' => $supported
439 ));
440 }
441 }
442 }
443 closedir($dh);
444 }
445
446 $template->assign_vars(array(
447 'U_ACTION' => $this->u_action . '&amp;action=submit'
448 ));
449 break;
450 }
451 break;
452 }
453 }
454 }
455
456 /**
457 * @package acp
458 */
459 class base_extractor
460 {
461 var $fh;
462 var $fp;
463 var $write;
464 var $close;
465 var $store;
466 var $download;
467 var $time;
468 var $format;
469 var $run_comp = false;
470
471 function __construct($download = false, $store = false, $format, $filename, $time)
472 {
473 $this->download = $download;
474 $this->store = $store;
475 $this->time = $time;
476 $this->format = $format;
477
478 switch ($format)
479 {
480 case 'text':
481 $ext = '.sql';
482 $open = 'fopen';
483 $this->write = 'fwrite';
484 $this->close = 'fclose';
485 $mimetype = 'text/x-sql';
486 break;
487 case 'bzip2':
488 $ext = '.sql.bz2';
489 $open = 'bzopen';
490 $this->write = 'bzwrite';
491 $this->close = 'bzclose';
492 $mimetype = 'application/x-bzip2';
493 break;
494 case 'gzip':
495 $ext = '.sql.gz';
496 $open = 'gzopen';
497 $this->write = 'gzwrite';
498 $this->close = 'gzclose';
499 $mimetype = 'application/x-gzip';
500 break;
501 }
502
503 if ($download == true)
504 {
505 $name = $filename . $ext;
506 header('Pragma: no-cache');
507 header("Content-Type: $mimetype; name=\"$name\"");
508 header("Content-disposition: attachment; filename=$name");
509
510 switch ($format)
511 {
512 case 'bzip2':
513 ob_start();
514 break;
515
516 case 'gzip':
517 if ((isset($_SERVER['HTTP_ACCEPT_ENCODING']) && strpos($_SERVER['HTTP_ACCEPT_ENCODING'], 'gzip') !== false) && strpos(strtolower($_SERVER['HTTP_USER_AGENT']), 'msie') === false)
518 {
519 ob_start('ob_gzhandler');
520 }
521 else
522 {
523 $this->run_comp = true;
524 }
525 break;
526 }
527 }
528
529 if ($store == true)
530 {
531 $file = PHPBB_ROOT_PATH . 'store/' . $filename . $ext;
532
533 $this->fp = $open($file, 'w');
534
535 if (!$this->fp)
536 {
537 trigger_error('Unable to write temporary file to storage folder', E_USER_ERROR);
538 }
539 }
540 }
541
542 function write_end()
543 {
544 static $close;
545 if ($this->store)
546 {
547 if ($close === null)
548 {
549 $close = $this->close;
550 }
551 $close($this->fp);
552 }
553
554 // bzip2 must be written all the way at the end
555 if ($this->download && $this->format === 'bzip2')
556 {
557 $c = ob_get_clean();
558 echo bzcompress($c);
559 }
560 }
561
562 function flush($data)
563 {
564 static $write;
565 if ($this->store === true)
566 {
567 if ($write === null)
568 {
569 $write = $this->write;
570 }
571 $write($this->fp, $data);
572 }
573
574 if ($this->download === true)
575 {
576 if ($this->format === 'bzip2' || $this->format === 'text' || ($this->format === 'gzip' && !$this->run_comp))
577 {
578 echo $data;
579 }
580
581 // we can write the gzip data as soon as we get it
582 if ($this->format === 'gzip')
583 {
584 if ($this->run_comp)
585 {
586 echo gzencode($data);
587 }
588 else
589 {
590 ob_flush();
591 flush();
592 }
593 }
594 }
595 }
596 }
597
598 /**
599 * @package acp
600 */
601 class mysql_extractor extends base_extractor
602 {
603 function write_start($table_prefix)
604 {
605 $sql_data = "#\n";
606 $sql_data .= "# phpBB Backup Script\n";
607 $sql_data .= "# Dump of tables for $table_prefix\n";
608 $sql_data .= "# DATE : " . gmdate("d-m-Y H:i:s", $this->time) . " GMT\n";
609 $sql_data .= "#\n";
610 $this->flush($sql_data);
611 }
612
613 function write_table($table_name)
614 {
615 global $db;
616
617 $sql = 'SHOW CREATE TABLE ' . $table_name;
618 $result = $db->sql_query($sql);
619 $row = $db->sql_fetchrow($result);
620
621 $sql_data = '# Table: ' . $table_name . "\n";
622 $sql_data .= "DROP TABLE IF EXISTS $table_name;\n";
623 $this->flush($sql_data . $row['Create Table'] . ";\n\n");
624
625 $db->sql_freeresult($result);
626 }
627
628 function write_data($table_name)
629 {
630 global $db;
631 if ($db->sql_layer === 'mysqli')
632 {
633 $this->write_data_mysqli($table_name);
634 }
635 else
636 {
637 $this->write_data_mysql($table_name);
638 }
639 }
640
641 function write_data_mysqli($table_name)
642 {
643 global $db;
644 $sql = "SELECT *
645 FROM $table_name";
646 $result = mysqli_query($db->db_connect_id, $sql, MYSQLI_USE_RESULT);
647 if ($result != false)
648 {
649 $fields_cnt = mysqli_num_fields($result);
650
651 // Get field information
652 $field = mysqli_fetch_fields($result);
653 $field_set = array();
654
655 for ($j = 0; $j < $fields_cnt; $j++)
656 {
657 $field_set[] = $field[$j]->name;
658 }
659
660 $search = array("\\", "'", "\x00", "\x0a", "\x0d", "\x1a", '"');
661 $replace = array("\\\\", "\\'", '\0', '\n', '\r', '\Z', '\\"');
662 $fields = implode(', ', $field_set);
663 $sql_data = 'INSERT INTO ' . $table_name . ' (' . $fields . ') VALUES ';
664 $first_set = true;
665 $query_len = 0;
666 $max_len = get_usable_memory();
667
668 while ($row = mysqli_fetch_row($result))
669 {
670 $values = array();
671 if ($first_set)
672 {
673 $query = $sql_data . '(';
674 }
675 else
676 {
677 $query .= ',(';
678 }
679
680 for ($j = 0; $j < $fields_cnt; $j++)
681 {
682 if (!isset($row[$j]) || is_null($row[$j]))
683 {
684 $values[$j] = 'NULL';
685 }
686 else if (($field[$j]->flags & 32768) && !($field[$j]->flags & 1024))
687 {
688 $values[$j] = $row[$j];
689 }
690 else
691 {
692 $values[$j] = "'" . str_replace($search, $replace, $row[$j]) . "'";
693 }
694 }
695 $query .= implode(', ', $values) . ')';
696
697 $query_len += strlen($query);
698 if ($query_len > $max_len)
699 {
700 $this->flush($query . ";\n\n");
701 $query = '';
702 $query_len = 0;
703 $first_set = true;
704 }
705 else
706 {
707 $first_set = false;
708 }
709 }
710 mysqli_free_result($result);
711
712 // check to make sure we have nothing left to flush
713 if (!$first_set && $query)
714 {
715 $this->flush($query . ";\n\n");
716 }
717 }
718 }
719
720 function write_data_mysql($table_name)
721 {
722 global $db;
723 $sql = "SELECT *
724 FROM $table_name";
725 $result = mysql_unbuffered_query($sql, $db->db_connect_id);
726
727 if ($result != false)
728 {
729 $fields_cnt = mysql_num_fields($result);
730
731 // Get field information
732 $field = array();
733 for ($i = 0; $i < $fields_cnt; $i++)
734 {
735 $field[] = mysql_fetch_field($result, $i);
736 }
737 $field_set = array();
738
739 for ($j = 0; $j < $fields_cnt; $j++)
740 {
741 $field_set[] = $field[$j]->name;
742 }
743
744 $search = array("\\", "'", "\x00", "\x0a", "\x0d", "\x1a", '"');
745 $replace = array("\\\\", "\\'", '\0', '\n', '\r', '\Z', '\\"');
746 $fields = implode(', ', $field_set);
747 $sql_data = 'INSERT INTO ' . $table_name . ' (' . $fields . ') VALUES ';
748 $first_set = true;
749 $query_len = 0;
750 $max_len = get_usable_memory();
751
752 while ($row = mysql_fetch_row($result))
753 {
754 $values = array();
755 if ($first_set)
756 {
757 $query = $sql_data . '(';
758 }
759 else
760 {
761 $query .= ',(';
762 }
763
764 for ($j = 0; $j < $fields_cnt; $j++)
765 {
766 if (!isset($row[$j]) || is_null($row[$j]))
767 {
768 $values[$j] = 'NULL';
769 }
770 else if ($field[$j]->numeric && ($field[$j]->type !== 'timestamp'))
771 {
772 $values[$j] = $row[$j];
773 }
774 else
775 {
776 $values[$j] = "'" . str_replace($search, $replace, $row[$j]) . "'";
777 }
778 }
779 $query .= implode(', ', $values) . ')';
780
781 $query_len += strlen($query);
782 if ($query_len > $max_len)
783 {
784 $this->flush($query . ";\n\n");
785 $query = '';
786 $query_len = 0;
787 $first_set = true;
788 }
789 else
790 {
791 $first_set = false;
792 }
793 }
794 mysql_free_result($result);
795
796 // check to make sure we have nothing left to flush
797 if (!$first_set && $query)
798 {
799 $this->flush($query . ";\n\n");
800 }
801 }
802 }
803 }
804
805 /**
806 * @package acp
807 */
808 class sqlite_extractor extends base_extractor
809 {
810 function write_start($prefix)
811 {
812 $sql_data = "--\n";
813 $sql_data .= "-- phpBB Backup Script\n";
814 $sql_data .= "-- Dump of tables for $prefix\n";
815 $sql_data .= "-- DATE : " . gmdate("d-m-Y H:i:s", $this->time) . " GMT\n";
816 $sql_data .= "--\n";
817 $sql_data .= "BEGIN TRANSACTION;\n";
818 $this->flush($sql_data);
819 }
820
821 function write_table($table_name)
822 {
823 global $db;
824 $sql_data = '-- Table: ' . $table_name . "\n";
825 $sql_data .= "DROP TABLE $table_name;\n";
826
827 $sql = "SELECT sql
828 FROM sqlite_master
829 WHERE type = 'table'
830 AND name = '" . $db->sql_escape($table_name) . "'
831 ORDER BY type DESC, name;";
832 $result = $db->sql_query($sql);
833 $row = $db->sql_fetchrow($result);
834 $db->sql_freeresult($result);
835
836 // Create Table
837 $sql_data .= $row['sql'] . ";\n";
838
839 $result = $db->sql_query("PRAGMA index_list('" . $db->sql_escape($table_name) . "');");
840
841 $ar = array();
842 while ($row = $db->sql_fetchrow($result))
843 {
844 $ar[] = $row;
845 }
846 $db->sql_freeresult($result);
847
848 foreach ($ar as $value)
849 {
850 if (strpos($value['name'], 'autoindex') !== false)
851 {
852 continue;
853 }
854
855 $result = $db->sql_query("PRAGMA index_info('" . $db->sql_escape($value['name']) . "');");
856
857 $fields = array();
858 while ($row = $db->sql_fetchrow($result))
859 {
860 $fields[] = $row['name'];
861 }
862 $db->sql_freeresult($result);
863
864 $sql_data .= 'CREATE ' . ($value['unique'] ? 'UNIQUE ' : '') . 'INDEX ' . $value['name'] . ' on ' . $table_name . ' (' . implode(', ', $fields) . ");\n";
865 }
866
867 $this->flush($sql_data . "\n");
868 }
869
870 function write_data($table_name)
871 {
872 global $db;
873 static $proper;
874
875 if (is_null($proper))
876 {
877 $proper = version_compare(PHP_VERSION, '5.1.3', '>=');
878 }
879
880 if ($proper)
881 {
882 $col_types = sqlite_fetch_column_types($db->db_connect_id, $table_name);
883 }
884 else
885 {
886 $sql = "SELECT sql
887 FROM sqlite_master
888 WHERE type = 'table'
889 AND name = '" . $table_name . "'";
890 $table_data = sqlite_single_query($db->db_connect_id, $sql);
891 $table_data = preg_replace('#CREATE\s+TABLE\s+"?' . $table_name . '"?#i', '', $table_data);
892 $table_data = trim($table_data);
893
894 preg_match('#\((.*)\)#s', $table_data, $matches);
895
896 $table_cols = explode(',', trim($matches[1]));
897 foreach ($table_cols as $declaration)
898 {
899 $entities = preg_split('#\s+#', trim($declaration));
900 $column_name = preg_replace('/"?([^"]+)"?/', '\1', $entities[0]);
901
902 // Hit a primary key, those are not what we need :D
903 if (empty($entities[1]) || (strtolower($entities[0]) === 'primary' && strtolower($entities[1]) === 'key'))
904 {
905 continue;
906 }
907 $col_types[$column_name] = $entities[1];
908 }
909 }
910
911 $sql = "SELECT *
912 FROM $table_name";
913 $result = sqlite_unbuffered_query($db->db_connect_id, $sql);
914 $rows = sqlite_fetch_all($result, SQLITE_ASSOC);
915 $sql_insert = 'INSERT INTO ' . $table_name . ' (' . implode(', ', array_keys($col_types)) . ') VALUES (';
916 foreach ($rows as $row)
917 {
918 foreach ($row as $column_name => $column_data)
919 {
920 if (is_null($column_data))
921 {
922 $row[$column_name] = 'NULL';
923 }
924 else if ($column_data == '')
925 {
926 $row[$column_name] = "''";
927 }
928 else if (strpos($col_types[$column_name], 'text') !== false || strpos($col_types[$column_name], 'char') !== false || strpos($col_types[$column_name], 'blob') !== false)
929 {
930 $row[$column_name] = sanitize_data_generic(str_replace("'", "''", $column_data));
931 }
932 }
933 $this->flush($sql_insert . implode(', ', $row) . ");\n");
934 }
935 }
936
937 function write_end()
938 {
939 $this->flush("COMMIT;\n");
940 parent::write_end();
941 }
942 }
943
944 /**
945 * @package acp
946 */
947 class postgres_extractor extends base_extractor
948 {
949 function write_start($prefix)
950 {
951 $sql_data = "--\n";
952 $sql_data .= "-- phpBB Backup Script\n";
953 $sql_data .= "-- Dump of tables for $prefix\n";
954 $sql_data .= "-- DATE : " . gmdate("d-m-Y H:i:s", $this->time) . " GMT\n";
955 $sql_data .= "--\n";
956 $sql_data .= "BEGIN TRANSACTION;\n";
957 $this->flush($sql_data);
958 }
959
960 function write_table($table_name)
961 {
962 global $db;
963 static $domains_created = array();
964
965 $sql = "SELECT a.domain_name, a.data_type, a.character_maximum_length, a.domain_default
966 FROM INFORMATION_SCHEMA.domains a, INFORMATION_SCHEMA.column_domain_usage b
967 WHERE a.domain_name = b.domain_name
968 AND b.table_name = '{$table_name}'";
969 $result = $db->sql_query($sql);
970 while ($row = $db->sql_fetchrow($result))
971 {
972 if (empty($domains_created[$row['domain_name']]))
973 {
974 $domains_created[$row['domain_name']] = true;
975 //$sql_data = "DROP DOMAIN {$row['domain_name']};\n";
976 $sql_data = "CREATE DOMAIN {$row['domain_name']} as {$row['data_type']}";
977 if (!empty($row['character_maximum_length']))
978 {
979 $sql_data .= '(' . $row['character_maximum_length'] . ')';
980 }
981 $sql_data .= ' NOT NULL';
982 if (!empty($row['domain_default']))
983 {
984 $sql_data .= ' DEFAULT ' . $row['domain_default'];
985 }
986 $this->flush($sql_data . ";\n");
987 }
988 }
989
990 $sql_data = '-- Table: ' . $table_name . "\n";
991 $sql_data .= "DROP TABLE $table_name;\n";
992 // PGSQL does not "tightly" bind sequences and tables, we must guess...
993 $sql = "SELECT relname
994 FROM pg_class
995 WHERE relkind = 'S'
996 AND relname = '{$table_name}_seq'";
997 $result = $db->sql_query($sql);
998 // We don't even care about storing the results. We already know the answer if we get rows back.
999 if ($db->sql_fetchrow($result))
1000 {
1001 $sql_data .= "DROP SEQUENCE {$table_name}_seq;\n";
1002 $sql_data .= "CREATE SEQUENCE {$table_name}_seq;\n";
1003 }
1004 $db->sql_freeresult($result);
1005
1006 $field_query = "SELECT a.attnum, a.attname as field, t.typname as type, a.attlen as length, a.atttypmod as lengthvar, a.attnotnull as notnull
1007 FROM pg_class c, pg_attribute a, pg_type t
1008 WHERE c.relname = '" . $db->sql_escape($table_name) . "'
1009 AND a.attnum > 0
1010 AND a.attrelid = c.oid
1011 AND a.atttypid = t.oid
1012 ORDER BY a.attnum";
1013 $result = $db->sql_query($field_query);
1014
1015 $sql_data .= "CREATE TABLE $table_name(\n";
1016 $lines = array();
1017 while ($row = $db->sql_fetchrow($result))
1018 {
1019 // Get the data from the table
1020 $sql_get_default = "SELECT pg_get_expr(d.adbin, d.adrelid) as rowdefault
1021 FROM pg_attrdef d, pg_class c
1022 WHERE (c.relname = '" . $db->sql_escape($table_name) . "')
1023 AND (c.oid = d.adrelid)
1024 AND d.adnum = " . $row['attnum'];
1025 $def_res = $db->sql_query($sql_get_default);
1026
1027 if (!$def_res)
1028 {
1029 unset($row['rowdefault']);
1030 }
1031 else
1032 {
1033 $row['rowdefault'] = $db->sql_fetchfield('rowdefault', $def_res);
1034 }
1035 $db->sql_freeresult($def_res);
1036
1037 if ($row['type'] == 'bpchar')
1038 {
1039 // Internally stored as bpchar, but isn't accepted in a CREATE TABLE statement.
1040 $row['type'] = 'char';
1041 }
1042
1043 $line = ' ' . $row['field'] . ' ' . $row['type'];
1044
1045 if (strpos($row['type'], 'char') !== false)
1046 {
1047 if ($row['lengthvar'] > 0)
1048 {
1049 $line .= '(' . ($row['lengthvar'] - 4) . ')';
1050 }
1051 }
1052
1053 if (strpos($row['type'], 'numeric') !== false)
1054 {
1055 $line .= '(';
1056 $line .= sprintf("%s,%s", (($row['lengthvar'] >> 16) & 0xffff), (($row['lengthvar'] - 4) & 0xffff));
1057 $line .= ')';
1058 }
1059
1060 if (isset($row['rowdefault']))
1061 {
1062 $line .= ' DEFAULT ' . $row['rowdefault'];
1063 }
1064
1065 if ($row['notnull'] == 't')
1066 {
1067 $line .= ' NOT NULL';
1068 }
1069
1070 $lines[] = $line;
1071 }
1072 $db->sql_freeresult($result);
1073
1074
1075 // Get the listing of primary keys.
1076 $sql_pri_keys = "SELECT ic.relname as index_name, bc.relname as tab_name, ta.attname as column_name, i.indisunique as unique_key, i.indisprimary as primary_key
1077 FROM pg_class bc, pg_class ic, pg_index i, pg_attribute ta, pg_attribute ia
1078 WHERE (bc.oid = i.indrelid)
1079 AND (ic.oid = i.indexrelid)
1080 AND (ia.attrelid = i.indexrelid)
1081 AND (ta.attrelid = bc.oid)
1082 AND (bc.relname = '" . $db->sql_escape($table_name) . "')
1083 AND (ta.attrelid = i.indrelid)
1084 AND (ta.attnum = i.indkey[ia.attnum-1])
1085 ORDER BY index_name, tab_name, column_name";
1086
1087 $result = $db->sql_query($sql_pri_keys);
1088
1089 $index_create = $index_rows = $primary_key = array();
1090
1091 // We do this in two steps. It makes placing the comma easier
1092 while ($row = $db->sql_fetchrow($result))
1093 {
1094 if ($row['primary_key'] == 't')
1095 {
1096 $primary_key[] = $row['column_name'];
1097 $primary_key_name = $row['index_name'];
1098 }
1099 else
1100 {
1101 // We have to store this all this info because it is possible to have a multi-column key...
1102 // we can loop through it again and build the statement
1103 $index_rows[$row['index_name']]['table'] = $table_name;
1104 $index_rows[$row['index_name']]['unique'] = ($row['unique_key'] == 't') ? true : false;
1105 $index_rows[$row['index_name']]['column_names'][] = $row['column_name'];
1106 }
1107 }
1108 $db->sql_freeresult($result);
1109
1110 if (!empty($index_rows))
1111 {
1112 foreach ($index_rows as $idx_name => $props)
1113 {
1114 $index_create[] = 'CREATE ' . ($props['unique'] ? 'UNIQUE ' : '') . "INDEX $idx_name ON $table_name (" . implode(', ', $props['column_names']) . ");";
1115 }
1116 }
1117
1118 if (!empty($primary_key))
1119 {
1120 $lines[] = " CONSTRAINT $primary_key_name PRIMARY KEY (" . implode(', ', $primary_key) . ")";
1121 }
1122
1123 // Generate constraint clauses for CHECK constraints
1124 $sql_checks = "SELECT conname as index_name, consrc
1125 FROM pg_constraint, pg_class bc
1126 WHERE conrelid = bc.oid
1127 AND bc.relname = '" . $db->sql_escape($table_name) . "'
1128 AND NOT EXISTS (
1129 SELECT *
1130 FROM pg_constraint as c, pg_inherits as i
1131 WHERE i.inhrelid = pg_constraint.conrelid
1132 AND c.conname = pg_constraint.conname
1133 AND c.consrc = pg_constraint.consrc
1134 AND c.conrelid = i.inhparent
1135 )";
1136 $result = $db->sql_query($sql_checks);
1137
1138 // Add the constraints to the sql file.
1139 while ($row = $db->sql_fetchrow($result))
1140 {
1141 if (!is_null($row['consrc']))
1142 {
1143 $lines[] = ' CONSTRAINT ' . $row['index_name'] . ' CHECK ' . $row['consrc'];
1144 }
1145 }
1146 $db->sql_freeresult($result);
1147
1148 $sql_data .= implode(", \n", $lines);
1149 $sql_data .= "\n);\n";
1150
1151 if (!empty($index_create))
1152 {
1153 $sql_data .= implode("\n", $index_create) . "\n\n";
1154 }
1155 $this->flush($sql_data);
1156 }
1157
1158 function write_data($table_name)
1159 {
1160 global $db;
1161 // Grab all of the data from current table.
1162 $sql = "SELECT *
1163 FROM $table_name";
1164 $result = $db->sql_query($sql);
1165
1166 $i_num_fields = pg_num_fields($result);
1167 $seq = '';
1168
1169 for ($i = 0; $i < $i_num_fields; $i++)
1170 {
1171 $ary_type[] = pg_field_type($result, $i);
1172 $ary_name[] = pg_field_name($result, $i);
1173
1174
1175 $sql = "SELECT pg_get_expr(d.adbin, d.adrelid) as rowdefault
1176 FROM pg_attrdef d, pg_class c
1177 WHERE (c.relname = '{$table_name}')
1178 AND (c.oid = d.adrelid)
1179 AND d.adnum = " . strval($i + 1);
1180 $result2 = $db->sql_query($sql);
1181 if ($row = $db->sql_fetchrow($result2))
1182 {
1183 // Determine if we must reset the sequences
1184 if (strpos($row['rowdefault'], "nextval('") === 0)
1185 {
1186 $seq .= "SELECT SETVAL('{$table_name}_seq',(select case when max({$ary_name[$i]})>0 then max({$ary_name[$i]})+1 else 1 end FROM {$table_name}));\n";
1187 }
1188 }
1189 }
1190
1191 $this->flush("COPY $table_name (" . implode(', ', $ary_name) . ') FROM stdin;' . "\n");
1192 while ($row = $db->sql_fetchrow($result))
1193 {
1194 $schema_vals = array();
1195
1196 // Build the SQL statement to recreate the data.
1197 for ($i = 0; $i < $i_num_fields; $i++)
1198 {
1199 $str_val = $row[$ary_name[$i]];
1200
1201 if (preg_match('#char|text|bool|bytea#i', $ary_type[$i]))
1202 {
1203 $str_val = str_replace(array("\n", "\t", "\r", "\b", "\f", "\v"), array('\n', '\t', '\r', '\b', '\f', '\v'), addslashes($str_val));
1204 $str_empty = '';
1205 }
1206 else
1207 {
1208 $str_empty = '\N';
1209 }
1210
1211 if (empty($str_val) && $str_val !== '0')
1212 {
1213 $str_val = $str_empty;
1214 }
1215
1216 $schema_vals[] = $str_val;
1217 }
1218
1219 // Take the ordered fields and their associated data and build it
1220 // into a valid sql statement to recreate that field in the data.
1221 $this->flush(implode("\t", $schema_vals) . "\n");
1222 }
1223 $db->sql_freeresult($result);
1224 $this->flush("\\.\n");
1225
1226 // Write out the sequence statements
1227 $this->flush($seq);
1228 }
1229
1230 function write_end()
1231 {
1232 $this->flush("COMMIT;\n");
1233 parent::write_end();
1234 }
1235 }
1236
1237 /**
1238 * @package acp
1239 */
1240 class mssql_extractor extends base_extractor
1241 {
1242 function write_end()
1243 {
1244 $this->flush("COMMIT\nGO\n");
1245 parent::write_end();
1246 }
1247
1248 function write_start($prefix)
1249 {
1250 $sql_data = "--\n";
1251 $sql_data .= "-- phpBB Backup Script\n";
1252 $sql_data .= "-- Dump of tables for $prefix\n";
1253 $sql_data .= "-- DATE : " . gmdate("d-m-Y H:i:s", $this->time) . " GMT\n";
1254 $sql_data .= "--\n";
1255 $sql_data .= "BEGIN TRANSACTION\n";
1256 $sql_data .= "GO\n";
1257 $this->flush($sql_data);
1258 }
1259
1260 function write_table($table_name)
1261 {
1262 global $db;
1263 $sql_data = '-- Table: ' . $table_name . "\n";
1264 $sql_data .= "IF OBJECT_ID(N'$table_name', N'U') IS NOT NULL\n";
1265 $sql_data .= "DROP TABLE $table_name;\n";
1266 $sql_data .= "GO\n";
1267 $sql_data .= "\nCREATE TABLE [$table_name] (\n";
1268 $rows = array();
1269
1270 $text_flag = false;
1271
1272 $sql = "SELECT COLUMN_NAME, COLUMN_DEFAULT, IS_NULLABLE, DATA_TYPE, CHARACTER_MAXIMUM_LENGTH, COLUMNPROPERTY(object_id(TABLE_NAME), COLUMN_NAME, 'IsIdentity') as IS_IDENTITY
1273 FROM INFORMATION_SCHEMA.COLUMNS
1274 WHERE TABLE_NAME = '$table_name'";
1275 $result = $db->sql_query($sql);
1276
1277 while ($row = $db->sql_fetchrow($result))
1278 {
1279 $line = "\t[{$row['COLUMN_NAME']}] [{$row['DATA_TYPE']}]";
1280
1281 if ($row['DATA_TYPE'] == 'text')
1282 {
1283 $text_flag = true;
1284 }
1285
1286 if ($row['IS_IDENTITY'])
1287 {
1288 $line .= ' IDENTITY (1 , 1)';
1289 }
1290
1291 if ($row['CHARACTER_MAXIMUM_LENGTH'] && $row['DATA_TYPE'] !== 'text')
1292 {
1293 $line .= ' (' . $row['CHARACTER_MAXIMUM_LENGTH'] . ')';
1294 }
1295
1296 if ($row['IS_NULLABLE'] == 'YES')
1297 {
1298 $line .= ' NULL';
1299 }
1300 else
1301 {
1302 $line .= ' NOT NULL';
1303 }
1304
1305 if ($row['COLUMN_DEFAULT'])
1306 {
1307 $line .= ' DEFAULT ' . $row['COLUMN_DEFAULT'];
1308 }
1309
1310 $rows[] = $line;
1311 }
1312 $db->sql_freeresult($result);
1313
1314 $sql_data .= implode(",\n", $rows);
1315 $sql_data .= "\n) ON [PRIMARY]";
1316
1317 if ($text_flag)
1318 {
1319 $sql_data .= " TEXTIMAGE_ON [PRIMARY]";
1320 }
1321
1322 $sql_data .= "\nGO\n\n";
1323 $rows = array();
1324
1325 $sql = "SELECT CONSTRAINT_NAME, COLUMN_NAME
1326 FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
1327 WHERE TABLE_NAME = '$table_name'";
1328 $result = $db->sql_query($sql);
1329 while ($row = $db->sql_fetchrow($result))
1330 {
1331 if (!sizeof($rows))
1332 {
1333 $sql_data .= "ALTER TABLE [$table_name] WITH NOCHECK ADD\n";
1334 $sql_data .= "\tCONSTRAINT [{$row['CONSTRAINT_NAME']}] PRIMARY KEY CLUSTERED \n\t(\n";
1335 }
1336 $rows[] = "\t\t[{$row['COLUMN_NAME']}]";
1337 }
1338 if (sizeof($rows))
1339 {
1340 $sql_data .= implode(",\n", $rows);
1341 $sql_data .= "\n\t) ON [PRIMARY] \nGO\n";
1342 }
1343 $db->sql_freeresult($result);
1344
1345 $index = array();
1346 $sql = "EXEC sp_statistics '$table_name'";
1347 $result = $db->sql_query($sql);
1348 while ($row = $db->sql_fetchrow($result))
1349 {
1350 if ($row['TYPE'] == 3)
1351 {
1352 $index[$row['INDEX_NAME']][] = '[' . $row['COLUMN_NAME'] . ']';
1353 }
1354 }
1355 $db->sql_freeresult($result);
1356
1357 foreach ($index as $index_name => $column_name)
1358 {
1359 $index[$index_name] = implode(', ', $column_name);
1360 }
1361
1362 foreach ($index as $index_name => $columns)
1363 {
1364 $sql_data .= "\nCREATE INDEX [$index_name] ON [$table_name]($columns) ON [PRIMARY]\nGO\n";
1365 }
1366 $this->flush($sql_data);
1367 }
1368
1369 function write_data($table_name)
1370 {
1371 global $db;
1372
1373 if ($db->sql_layer === 'mssql')
1374 {
1375 $this->write_data_mssql($table_name);
1376 }
1377 else if ($db->sql_layer === 'mssql_odbc')
1378 {
1379 $this->write_data_odbc($table_name);
1380 }
1381 else
1382 {
1383 // @todo: write code for MS SQL 2005 DBAL
1384 trigger_error('KungFuDeathGrip');
1385 }
1386 }
1387
1388 function write_data_mssql($table_name)
1389 {
1390 global $db;
1391 $ary_type = $ary_name = array();
1392 $ident_set = false;
1393 $sql_data = '';
1394
1395 // Grab all of the data from current table.
1396 $sql = "SELECT *
1397 FROM $table_name";
1398 $result = $db->sql_query($sql);
1399
1400 $retrieved_data = mssql_num_rows($result);
1401
1402 $i_num_fields = mssql_num_fields($result);
1403
1404 for ($i = 0; $i < $i_num_fields; $i++)
1405 {
1406 $ary_type[$i] = mssql_field_type($result, $i);
1407 $ary_name[$i] = mssql_field_name($result, $i);
1408 }
1409
1410 if ($retrieved_data)
1411 {
1412 $sql = "SELECT 1 as has_identity
1413 FROM INFORMATION_SCHEMA.COLUMNS
1414 WHERE COLUMNPROPERTY(object_id('$table_name'), COLUMN_NAME, 'IsIdentity') = 1";
1415 $result2 = $db->sql_query($sql);
1416 $row2 = $db->sql_fetchrow($result2);
1417 if (!empty($row2['has_identity']))
1418 {
1419 $sql_data .= "\nSET IDENTITY_INSERT $table_name ON\nGO\n";
1420 $ident_set = true;
1421 }
1422 $db->sql_freeresult($result2);
1423 }
1424
1425 while ($row = $db->sql_fetchrow($result))
1426 {
1427 $schema_vals = $schema_fields = array();
1428
1429 // Build the SQL statement to recreate the data.
1430 for ($i = 0; $i < $i_num_fields; $i++)
1431 {
1432 $str_val = $row[$ary_name[$i]];
1433
1434 if (preg_match('#char|text|bool|varbinary#i', $ary_type[$i]))
1435 {
1436 $str_quote = '';
1437 $str_empty = "''";
1438 $str_val = sanitize_data_mssql(str_replace("'", "''", $str_val));
1439 }
1440 else if (preg_match('#date|timestamp#i', $ary_type[$i]))
1441 {
1442 if (empty($str_val))
1443 {
1444 $str_quote = '';
1445 }
1446 else
1447 {
1448 $str_quote = "'";
1449 }
1450 }
1451 else
1452 {
1453 $str_quote = '';
1454 $str_empty = 'NULL';
1455 }
1456
1457 if (empty($str_val) && $str_val !== '0' && !(is_int($str_val) || is_float($str_val)))
1458 {
1459 $str_val = $str_empty;
1460 }
1461
1462 $schema_vals[$i] = $str_quote . $str_val . $str_quote;
1463 $schema_fields[$i] = $ary_name[$i];
1464 }
1465
1466 // Take the ordered fields and their associated data and build it
1467 // into a valid sql statement to recreate that field in the data.
1468 $sql_data .= "INSERT INTO $table_name (" . implode(', ', $schema_fields) . ') VALUES (' . implode(', ', $schema_vals) . ");\nGO\n";
1469
1470 $this->flush($sql_data);
1471 $sql_data = '';
1472 }
1473 $db->sql_freeresult($result);
1474
1475 if ($retrieved_data && $ident_set)
1476 {
1477 $sql_data .= "\nSET IDENTITY_INSERT $table_name OFF\nGO\n";
1478 }
1479 $this->flush($sql_data);
1480 }
1481
1482 function write_data_odbc($table_name)
1483 {
1484 global $db;
1485 $ary_type = $ary_name = array();
1486 $ident_set = false;
1487 $sql_data = '';
1488
1489 // Grab all of the data from current table.
1490 $sql = "SELECT *
1491 FROM $table_name";
1492 $result = $db->sql_query($sql);
1493
1494 $retrieved_data = odbc_num_rows($result);
1495
1496 if ($retrieved_data)
1497 {
1498 $sql = "SELECT 1 as has_identity
1499 FROM INFORMATION_SCHEMA.COLUMNS
1500 WHERE COLUMNPROPERTY(object_id('$table_name'), COLUMN_NAME, 'IsIdentity') = 1";
1501 $result2 = $db->sql_query($sql);
1502 $row2 = $db->sql_fetchrow($result2);
1503 if (!empty($row2['has_identity']))
1504 {
1505 $sql_data .= "\nSET IDENTITY_INSERT $table_name ON\nGO\n";
1506 $ident_set = true;
1507 }
1508 $db->sql_freeresult($result2);
1509 }
1510
1511 $i_num_fields = odbc_num_fields($result);
1512
1513 for ($i = 0; $i < $i_num_fields; $i++)
1514 {
1515 $ary_type[$i] = odbc_field_type($result, $i + 1);
1516 $ary_name[$i] = odbc_field_name($result, $i + 1);
1517 }
1518
1519 while ($row = $db->sql_fetchrow($result))
1520 {
1521 $schema_vals = $schema_fields = array();
1522
1523 // Build the SQL statement to recreate the data.
1524 for ($i = 0; $i < $i_num_fields; $i++)
1525 {
1526 $str_val = $row[$ary_name[$i]];
1527
1528 if (preg_match('#char|text|bool|varbinary#i', $ary_type[$i]))
1529 {
1530 $str_quote = '';
1531 $str_empty = "''";
1532 $str_val = sanitize_data_mssql(str_replace("'", "''", $str_val));
1533 }
1534 else if (preg_match('#date|timestamp#i', $ary_type[$i]))
1535 {
1536 if (empty($str_val))
1537 {
1538 $str_quote = '';
1539 }
1540 else
1541 {
1542 $str_quote = "'";
1543 }
1544 }
1545 else
1546 {
1547 $str_quote = '';
1548 $str_empty = 'NULL';
1549 }
1550
1551 if (empty($str_val) && $str_val !== '0' && !(is_int($str_val) || is_float($str_val)))
1552 {
1553 $str_val = $str_empty;
1554 }
1555
1556 $schema_vals[$i] = $str_quote . $str_val . $str_quote;
1557 $schema_fields[$i] = $ary_name[$i];
1558 }
1559
1560 // Take the ordered fields and their associated data and build it
1561 // into a valid sql statement to recreate that field in the data.
1562 $sql_data .= "INSERT INTO $table_name (" . implode(', ', $schema_fields) . ') VALUES (' . implode(', ', $schema_vals) . ");\nGO\n";
1563
1564 $this->flush($sql_data);
1565
1566 $sql_data = '';
1567
1568 }
1569 $db->sql_freeresult($result);
1570
1571 if ($retrieved_data && $ident_set)
1572 {
1573 $sql_data .= "\nSET IDENTITY_INSERT $table_name OFF\nGO\n";
1574 }
1575 $this->flush($sql_data);
1576 }
1577
1578 }
1579
1580 /**
1581 * @package acp
1582 */
1583 class db2_extractor extends base_extractor
1584 {
1585 function write_start($prefix)
1586 {
1587 $sql_data = "--\n";
1588 $sql_data .= "-- phpBB Backup Script\n";
1589 $sql_data .= "-- Dump of tables for $prefix\n";
1590 $sql_data .= "-- DATE : " . gmdate("d-m-Y H:i:s", $this->time) . " GMT\n";
1591 $sql_data .= "--\n";
1592 $this->flush($sql_data);
1593 }
1594
1595 function write_table($table_name)
1596 {
1597 global $db;
1598 $sql_data = '-- Table: ' . $table_name . "\n";
1599 $sql_data .= "\nCREATE TABLE $table_name (\n";
1600 $rows = array();
1601
1602 // switch to db2_columns()?
1603 $sql = "SELECT colname, typename, length, default, identity, nulls
1604 FROM syscat.columns
1605 WHERE tabname = '$table_name'";
1606 $result = $db->sql_query($sql);
1607
1608 while ($row = $db->sql_fetchrow($result))
1609 {
1610 $line = "\t{$row['colname']} {$row['typename']}";
1611
1612 if ($row['identity'] == 'Y')
1613 {
1614 $line .= ' GENERATED BY DEFAULT AS IDENTITY (START WITH 1, INCREMENT BY 1)';
1615 }
1616
1617 if ($row['typename'] == 'VARCHAR' || $row['typename'] == 'CHARACTER' || $row['typename'] == 'CLOB')
1618 {
1619 $line .= ' (' . $row['length'] . ')';
1620 }
1621
1622 if ($row['nulls'] == 'N')
1623 {
1624 $line .= ' NOT NULL';
1625 }
1626 else
1627 {
1628 $line .= ' NULL';
1629 }
1630
1631 if ($row['default'] !== null)
1632 {
1633 $line .= ' DEFAULT ' . $row['default'];
1634 }
1635
1636 $rows[] = $line;
1637 }
1638 $db->sql_freeresult($result);
1639
1640 // switch to db2_columns()?
1641 $sql = "SELECT colname
1642 FROM SYSCAT.KEYCOLUSE
1643 WHERE tabname = '$table_name'";
1644 $result = $db->sql_query($sql);
1645 $prim_cols = array();
1646 while ($row = $db->sql_fetchrow($result))
1647 {
1648 $prim_cols[] = $row['colname'];
1649 }
1650 $db->sql_freeresult($result);
1651 if (sizeof($prim_cols))
1652 {
1653 $rows[] = "\tPRIMARY KEY (" . implode($prim_cols) . ')';
1654 }
1655
1656 $sql_data .= implode(",\n", $rows);
1657 $sql_data .= "\n);\n\n";
1658 $rows = array();
1659
1660 $sql = "SELECT colnames, indname
1661 FROM SYSCAT.INDEXES
1662 WHERE TABNAME = '$table_name'
1663 AND UNIQUERULE <> 'P'";
1664 $result = $db->sql_query($sql);
1665 $index = array();
1666 while ($row = $db->sql_fetchrow($result))
1667 {
1668 $inds = explode('+', $row['colnames']);
1669 unset($inds[0]);
1670 $sql_data .= 'CREATE INDEX ' . $row['indname'] . ' ON ' . $table_name . ' (' . implode(', ', $inds) . ") PCTFREE 10 MINPCTUSED 10 ALLOW REVERSE SCANS PAGE SPLIT SYMMETRIC COLLECT SAMPLED DETAILED STATISTICS;\n";
1671 }
1672 $db->sql_freeresult($result);
1673
1674 $this->flush($sql_data);
1675 }
1676
1677 function write_data($table_name)
1678 {
1679 global $db;
1680 $ary_type = $ary_name = array();
1681 $result = db2_columns($db->db_connect_id, '', '%', $table_name);
1682 $i = 0;
1683 while ($row = $db->sql_fetchrow($result))
1684 {
1685 $ary_type[$i] = $row['type_name'];
1686 $ary_name[$i++] = strtolower($row['column_name']);
1687 }
1688 $db->sql_freeresult($result);
1689
1690 // Grab all of the data from current table.
1691 $sql = "SELECT *
1692 FROM $table_name";
1693 $result = $db->sql_query($sql);
1694
1695 $sql_data = '';
1696 $i_num_fields = $i;
1697
1698 while ($row = $db->sql_fetchrow($result))
1699 {
1700 $schema_vals = $schema_fields = array();
1701
1702 // Build the SQL statement to recreate the data.
1703 for ($i = 0; $i < $i_num_fields; $i++)
1704 {
1705 $str_val = $row[$ary_name[$i]];
1706
1707 if (preg_match('#char|clob#i', $ary_type[$i]))
1708 {
1709 $str_quote = "'";
1710 $str_empty = '';
1711 $str_val = sanitize_data_generic(str_replace("'", "''", $str_val));
1712 }
1713 else if (preg_match('#date|timestamp#i', $ary_type[$i]))
1714 {
1715 if (empty($str_val))
1716 {
1717 $str_quote = '';
1718 }
1719 else
1720 {
1721 $str_quote = "'";
1722 }
1723 }
1724 else
1725 {
1726 $str_quote = '';
1727 $str_empty = 'NULL';
1728 }
1729
1730 if (empty($str_val) && $str_val !== '0')
1731 {
1732 $str_val = $str_empty;
1733 }
1734
1735 $schema_vals[$i] = $str_quote . $str_val . $str_quote;
1736 $schema_fields[$i] = '"' . $ary_name[$i] . "'";
1737 }
1738
1739 // Take the ordered fields and their associated data and build it
1740 // into a valid sql statement to recreate that field in the data.
1741 $sql_data = "INSERT INTO $table_name (" . implode(', ', $schema_fields) . ') VALUES (' . implode(', ', $schema_vals) . ");\n";
1742
1743 $this->flush($sql_data);
1744 }
1745 $db->sql_freeresult($result);
1746 }
1747 }
1748
1749 /**
1750 * @package acp
1751 */
1752 class oracle_extractor extends base_extractor
1753 {
1754 function write_table($table_name)
1755 {
1756 global $db;
1757 $sql_data = '-- Table: ' . $table_name . "\n";
1758 $sql_data .= "DROP TABLE $table_name;\n";
1759 $sql_data .= '\\' . "\n";
1760 $sql_data .= "\nCREATE TABLE $table_name (\n";
1761
1762 $sql = "SELECT COLUMN_NAME, DATA_TYPE, DATA_PRECISION, DATA_LENGTH, NULLABLE, DATA_DEFAULT
1763 FROM ALL_TAB_COLS
1764 WHERE table_name = '{$table_name}'";
1765 $result = $db->sql_query($sql);
1766
1767 $rows = array();
1768 while ($row = $db->sql_fetchrow($result))
1769 {
1770 $line = ' "' . $row['column_name'] . '" ' . $row['data_type'];
1771
1772 if ($row['data_type'] !== 'CLOB')
1773 {
1774 if ($row['data_type'] !== 'VARCHAR2')
1775 {
1776 $line .= '(' . $row['data_precision'] . ')';
1777 }
1778 else
1779 {
1780 $line .= '(' . $row['data_length'] . ')';
1781 }
1782 }
1783
1784 if (!empty($row['data_default']))
1785 {
1786 $line .= ' DEFAULT ' . $row['data_default'];
1787 }
1788
1789 if ($row['nullable'] == 'N')
1790 {
1791 $line .= ' NOT NULL';
1792 }
1793 $rows[] = $line;
1794 }
1795 $db->sql_freeresult($result);
1796
1797 $sql = "SELECT A.CONSTRAINT_NAME, A.COLUMN_NAME
1798 FROM USER_CONS_COLUMNS A, USER_CONSTRAINTS B
1799 WHERE A.CONSTRAINT_NAME = B.CONSTRAINT_NAME
1800 AND B.CONSTRAINT_TYPE = 'P'
1801 AND A.TABLE_NAME = '{$table_name}'";
1802 $result = $db->sql_query($sql);
1803
1804 while ($row = $db->sql_fetchrow($result))
1805 {
1806 $rows[] = " CONSTRAINT {$row['constraint_name']} PRIMARY KEY ({$row['column_name']})";
1807 }
1808 $db->sql_freeresult($result);
1809
1810 $sql = "SELECT A.CONSTRAINT_NAME, A.COLUMN_NAME
1811 FROM USER_CONS_COLUMNS A, USER_CONSTRAINTS B
1812 WHERE A.CONSTRAINT_NAME = B.CONSTRAINT_NAME
1813 AND B.CONSTRAINT_TYPE = 'U'
1814 AND A.TABLE_NAME = '{$table_name}'";
1815 $result = $db->sql_query($sql);
1816
1817 while ($row = $db->sql_fetchrow($result))
1818 {
1819 $rows[] = " CONSTRAINT {$row['constraint_name']} UNIQUE ({$row['column_name']})";
1820 }
1821 $db->sql_freeresult($result);
1822
1823 $sql_data .= implode(",\n", $rows);
1824 $sql_data .= "\n)\n\\";
1825
1826 $sql = "SELECT A.REFERENCED_NAME
1827 FROM USER_DEPENDENCIES A, USER_TRIGGERS B
1828 WHERE A.REFERENCED_TYPE = 'SEQUENCE'
1829 AND A.NAME = B.TRIGGER_NAME
1830 AND B.TABLE_NAME = '{$table_name}'";
1831 $result = $db->sql_query($sql);
1832 while ($row = $db->sql_fetchrow($result))
1833 {
1834 $sql_data .= "\nCREATE SEQUENCE {$row['referenced_name']}\\\n";
1835 }
1836 $db->sql_freeresult($result);
1837
1838 $sql = "SELECT DESCRIPTION, WHEN_CLAUSE, TRIGGER_BODY
1839 FROM USER_TRIGGERS
1840 WHERE TABLE_NAME = '{$table_name}'";
1841 $result = $db->sql_query($sql);
1842 while ($row = $db->sql_fetchrow($result))
1843 {
1844 $sql_data .= "\nCREATE OR REPLACE TRIGGER {$row['description']}WHEN ({$row['when_clause']})\n{$row['trigger_body']}\\";
1845 }
1846 $db->sql_freeresult($result);
1847
1848 $sql = "SELECT A.INDEX_NAME, B.COLUMN_NAME
1849 FROM USER_INDEXES A, USER_IND_COLUMNS B
1850 WHERE A.UNIQUENESS = 'NONUNIQUE'
1851 AND A.INDEX_NAME = B.INDEX_NAME
1852 AND B.TABLE_NAME = '{$table_name}'";
1853 $result = $db->sql_query($sql);
1854
1855 $index = array();
1856
1857 while ($row = $db->sql_fetchrow($result))
1858 {
1859 $index[$row['index_name']][] = $row['column_name'];
1860 }
1861
1862 foreach ($index as $index_name => $column_names)
1863 {
1864 $sql_data .= "\nCREATE INDEX $index_name ON $table_name(" . implode(', ', $column_names) . ")\n\\";
1865 }
1866 $db->sql_freeresult($result);
1867 $this->flush($sql_data);
1868 }
1869
1870 function write_data($table_name)
1871 {
1872 global $db;
1873 $ary_type = $ary_name = array();
1874
1875 // Grab all of the data from current table.
1876 $sql = "SELECT *
1877 FROM $table_name";
1878 $result = $db->sql_query($sql);
1879
1880 $i_num_fields = ocinumcols($result);
1881
1882 for ($i = 0; $i < $i_num_fields; $i++)
1883 {
1884 $ary_type[$i] = ocicolumntype($result, $i + 1);
1885 $ary_name[$i] = ocicolumnname($result, $i + 1);
1886 }
1887
1888 $sql_data = '';
1889
1890 while ($row = $db->sql_fetchrow($result))
1891 {
1892 $schema_vals = $schema_fields = array();
1893
1894 // Build the SQL statement to recreate the data.
1895 for ($i = 0; $i < $i_num_fields; $i++)
1896 {
1897 $str_val = $row[$ary_name[$i]];
1898
1899 if (preg_match('#char|text|bool|raw#i', $ary_type[$i]))
1900 {
1901 $str_quote = '';
1902 $str_empty = "''";
1903 $str_val = sanitize_data_oracle($str_val);
1904 }
1905 else if (preg_match('#date|timestamp#i', $ary_type[$i]))
1906 {
1907 if (empty($str_val))
1908 {
1909 $str_quote = '';
1910 }
1911 else
1912 {
1913 $str_quote = "'";
1914 }
1915 }
1916 else
1917 {
1918 $str_quote = '';
1919 $str_empty = 'NULL';
1920 }
1921
1922 if (empty($str_val) && $str_val !== '0')
1923 {
1924 $str_val = $str_empty;
1925 }
1926
1927 $schema_vals[$i] = $str_quote . $str_val . $str_quote;
1928 $schema_fields[$i] = '"' . $ary_name[$i] . "'";
1929 }
1930
1931 // Take the ordered fields and their associated data and build it
1932 // into a valid sql statement to recreate that field in the data.
1933 $sql_data = "INSERT INTO $table_name (" . implode(', ', $schema_fields) . ') VALUES (' . implode(', ', $schema_vals) . ");\n";
1934
1935 $this->flush($sql_data);
1936 }
1937 $db->sql_freeresult($result);
1938 }
1939
1940 function write_start($prefix)
1941 {
1942 $sql_data = "--\n";
1943 $sql_data .= "-- phpBB Backup Script\n";
1944 $sql_data .= "-- Dump of tables for $prefix\n";
1945 $sql_data .= "-- DATE : " . gmdate("d-m-Y H:i:s", $this->time) . " GMT\n";
1946 $sql_data .= "--\n";
1947 $this->flush($sql_data);
1948 }
1949 }
1950
1951 /**
1952 * @package acp
1953 */
1954 class firebird_extractor extends base_extractor
1955 {
1956 function write_start($prefix)
1957 {
1958 $sql_data = "--\n";
1959 $sql_data .= "-- phpBB Backup Script\n";
1960 $sql_data .= "-- Dump of tables for $prefix\n";
1961 $sql_data .= "-- DATE : " . gmdate("d-m-Y H:i:s", $this->time) . " GMT\n";
1962 $sql_data .= "--\n";
1963 $this->flush($sql_data);
1964 }
1965
1966 function write_data($table_name)
1967 {
1968 global $db;
1969 $ary_type = $ary_name = array();
1970
1971 // Grab all of the data from current table.
1972 $sql = "SELECT *
1973 FROM $table_name";
1974 $result = $db->sql_query($sql);
1975
1976 $i_num_fields = ibase_num_fields($result);
1977
1978 for ($i = 0; $i < $i_num_fields; $i++)
1979 {
1980 $info = ibase_field_info($result, $i);
1981 $ary_type[$i] = $info['type'];
1982 $ary_name[$i] = $info['name'];
1983 }
1984
1985 while ($row = $db->sql_fetchrow($result))
1986 {
1987 $schema_vals = $schema_fields = array();
1988
1989 // Build the SQL statement to recreate the data.
1990 for ($i = 0; $i < $i_num_fields; $i++)
1991 {
1992 $str_val = $row[strtolower($ary_name[$i])];
1993
1994 if (preg_match('#char|text|bool|varbinary|blob#i', $ary_type[$i]))
1995 {
1996 $str_quote = '';
1997 $str_empty = "''";
1998 $str_val = sanitize_data_generic(str_replace("'", "''", $str_val));
1999 }
2000 else if (preg_match('#date|timestamp#i', $ary_type[$i]))
2001 {
2002 if (empty($str_val))
2003 {
2004 $str_quote = '';
2005 }
2006 else
2007 {
2008 $str_quote = "'";
2009 }
2010 }
2011 else
2012 {
2013 $str_quote = '';
2014 $str_empty = 'NULL';
2015 }
2016
2017 if (empty($str_val) && $str_val !== '0')
2018 {
2019 $str_val = $str_empty;
2020 }
2021
2022 $schema_vals[$i] = $str_quote . $str_val . $str_quote;
2023 $schema_fields[$i] = '"' . $ary_name[$i] . '"';
2024 }
2025
2026 // Take the ordered fields and their associated data and build it
2027 // into a valid sql statement to recreate that field in the data.
2028 $sql_data = "INSERT INTO $table_name (" . implode(', ', $schema_fields) . ') VALUES (' . implode(', ', $schema_vals) . ");\n";
2029
2030 $this->flush($sql_data);
2031 }
2032 $db->sql_freeresult($result);
2033 }
2034
2035 function write_table($table_name)
2036 {
2037 global $db;
2038
2039 $sql_data = '-- Table: ' . $table_name . "\n";
2040 $sql_data .= "DROP TABLE $table_name;\n";
2041
2042 $data_types = array(7 => 'SMALLINT', 8 => 'INTEGER', 10 => 'FLOAT', 12 => 'DATE', 13 => 'TIME', 14 => 'CHARACTER', 27 => 'DOUBLE PRECISION', 35 => 'TIMESTAMP', 37 => 'VARCHAR', 40 => 'CSTRING', 261 => 'BLOB', 701 => 'DECIMAL', 702 => 'NUMERIC');
2043
2044 $sql_data .= "\nCREATE TABLE $table_name (\n";
2045
2046 $sql = 'SELECT DISTINCT R.RDB$FIELD_NAME as FNAME, R.RDB$NULL_FLAG as NFLAG, R.RDB$DEFAULT_SOURCE as DSOURCE, F.RDB$FIELD_TYPE as FTYPE, F.RDB$FIELD_SUB_TYPE as STYPE, F.RDB$FIELD_LENGTH as FLEN
2047 FROM RDB$RELATION_FIELDS R
2048 JOIN RDB$FIELDS F ON R.RDB$FIELD_SOURCE=F.RDB$FIELD_NAME
2049 LEFT JOIN RDB$FIELD_DIMENSIONS D ON R.RDB$FIELD_SOURCE = D.RDB$FIELD_NAME
2050 WHERE F.RDB$SYSTEM_FLAG = 0
2051 AND R.RDB$RELATION_NAME = \''. $table_name . '\'
2052 ORDER BY R.RDB$FIELD_POSITION';
2053 $result = $db->sql_query($sql);
2054
2055 $rows = array();
2056 while ($row = $db->sql_fetchrow($result))
2057 {
2058 $line = "\t" . '"' . $row['fname'] . '" ' . $data_types[$row['ftype']];
2059
2060 if ($row['ftype'] == 261 && $row['stype'] == 1)
2061 {
2062 $line .= ' SUB_TYPE TEXT';
2063 }
2064
2065 if ($row['ftype'] == 37 || $row['ftype'] == 14)
2066 {
2067 $line .= ' (' . $row['flen'] . ')';
2068 }
2069
2070 if (!empty($row['dsource']))
2071 {
2072 $line .= ' ' . $row['dsource'];
2073 }
2074
2075 if (!empty($row['nflag']))
2076 {
2077 $line .= ' NOT NULL';
2078 }
2079 $rows[] = $line;
2080 }
2081 $db->sql_freeresult($result);
2082
2083 $sql_data .= implode(",\n", $rows);
2084 $sql_data .= "\n);\n";
2085 $keys = array();
2086
2087 $sql = 'SELECT I.RDB$FIELD_NAME as NAME
2088 FROM RDB$RELATION_CONSTRAINTS RC, RDB$INDEX_SEGMENTS I, RDB$INDICES IDX
2089 WHERE (I.RDB$INDEX_NAME = RC.RDB$INDEX_NAME)
2090 AND (IDX.RDB$INDEX_NAME = RC.RDB$INDEX_NAME)
2091 AND (RC.RDB$RELATION_NAME = \''. $table_name . '\')
2092 ORDER BY I.RDB$FIELD_POSITION';
2093 $result = $db->sql_query($sql);
2094
2095 while ($row = $db->sql_fetchrow($result))
2096 {
2097 $keys[] = $row['name'];
2098 }
2099
2100 if (sizeof($keys))
2101 {
2102 $sql_data .= "\nALTER TABLE $table_name ADD PRIMARY KEY (" . implode(', ', $keys) . ');';
2103 }
2104
2105 $db->sql_freeresult($result);
2106
2107 $sql = 'SELECT I.RDB$INDEX_NAME as INAME, I.RDB$UNIQUE_FLAG as UFLAG, S.RDB$FIELD_NAME as FNAME
2108 FROM RDB$INDICES I JOIN RDB$INDEX_SEGMENTS S ON S.RDB$INDEX_NAME=I.RDB$INDEX_NAME
2109 WHERE (I.RDB$SYSTEM_FLAG IS NULL OR I.RDB$SYSTEM_FLAG=0)
2110 AND I.RDB$FOREIGN_KEY IS NULL
2111 AND I.RDB$RELATION_NAME = \''. $table_name . '\'
2112 AND I.RDB$INDEX_NAME NOT STARTING WITH \'RDB$\'
2113 ORDER BY S.RDB$FIELD_POSITION';
2114 $result = $db->sql_query($sql);
2115
2116 $index = array();
2117 while ($row = $db->sql_fetchrow($result))
2118 {
2119 $index[$row['iname']]['unique'] = !empty($row['uflag']);
2120 $index[$row['iname']]['values'][] = $row['fname'];
2121 }
2122
2123 foreach ($index as $index_name => $data)
2124 {
2125 $sql_data .= "\nCREATE ";
2126 if ($data['unique'])
2127 {
2128 $sql_data .= 'UNIQUE ';
2129 }
2130 $sql_data .= "INDEX $index_name ON $table_name(" . implode(', ', $data['values']) . ");";
2131 }
2132 $sql_data .= "\n";
2133
2134 $db->sql_freeresult($result);
2135
2136 $sql = 'SELECT D1.RDB$DEPENDENT_NAME as DNAME, D1.RDB$FIELD_NAME as FNAME, D1.RDB$DEPENDENT_TYPE, R1.RDB$RELATION_NAME
2137 FROM RDB$DEPENDENCIES D1
2138 LEFT JOIN RDB$RELATIONS R1 ON ((D1.RDB$DEPENDENT_NAME = R1.RDB$RELATION_NAME) AND (NOT (R1.RDB$VIEW_BLR IS NULL)))
2139 WHERE (D1.RDB$DEPENDED_ON_TYPE = 0)
2140 AND (D1.RDB$DEPENDENT_TYPE <> 3)
2141 AND (D1.RDB$DEPENDED_ON_NAME = \'' . $table_name . '\')
2142 UNION SELECT DISTINCT F2.RDB$RELATION_NAME, D2.RDB$FIELD_NAME, D2.RDB$DEPENDENT_TYPE, R2.RDB$RELATION_NAME FROM RDB$DEPENDENCIES D2, RDB$RELATION_FIELDS F2
2143 LEFT JOIN RDB$RELATIONS R2 ON ((F2.RDB$RELATION_NAME = R2.RDB$RELATION_NAME) AND (NOT (R2.RDB$VIEW_BLR IS NULL)))
2144 WHERE (D2.RDB$DEPENDENT_TYPE = 3)
2145 AND (D2.RDB$DEPENDENT_NAME = F2.RDB$FIELD_SOURCE)
2146 AND (D2.RDB$DEPENDED_ON_NAME = \'' . $table_name . '\')
2147 ORDER BY 1, 2';
2148 $result = $db->sql_query($sql);
2149 while ($row = $db->sql_fetchrow($result))
2150 {
2151 $sql = 'SELECT T1.RDB$DEPENDED_ON_NAME as GEN, T1.RDB$FIELD_NAME, T1.RDB$DEPENDED_ON_TYPE
2152 FROM RDB$DEPENDENCIES T1
2153 WHERE (T1.RDB$DEPENDENT_NAME = \'' . $row['dname'] . '\')
2154 AND (T1.RDB$DEPENDENT_TYPE = 2 AND T1.RDB$DEPENDED_ON_TYPE = 14)
2155 UNION ALL SELECT DISTINCT D.RDB$DEPENDED_ON_NAME, D.RDB$FIELD_NAME, D.RDB$DEPENDED_ON_TYPE
2156 FROM RDB$DEPENDENCIES D, RDB$RELATION_FIELDS F
2157 WHERE (D.RDB$DEPENDENT_TYPE = 3)
2158 AND (D.RDB$DEPENDENT_NAME = F.RDB$FIELD_SOURCE)
2159 AND (F.RDB$RELATION_NAME = \'' . $row['dname'] . '\')
2160 ORDER BY 1,2';
2161 $result2 = $db->sql_query($sql);
2162 $row2 = $db->sql_fetchrow($result2);
2163 $db->sql_freeresult($result2);
2164 $gen_name = $row2['gen'];
2165
2166 $sql_data .= "\nDROP GENERATOR " . $gen_name . ";";
2167 $sql_data .= "\nSET TERM ^ ;";
2168 $sql_data .= "\nCREATE GENERATOR " . $gen_name . "^";
2169 $sql_data .= "\nSET GENERATOR " . $gen_name . " TO 0^\n";
2170 $sql_data .= "\nCREATE TRIGGER {$row['dname']} FOR $table_name";
2171 $sql_data .= "\nBEFORE INSERT\nAS\nBEGIN";
2172 $sql_data .= "\n NEW.{$row['fname']} = GEN_ID(" . $gen_name . ", 1);";
2173 $sql_data .= "\nEND^\n";
2174 $sql_data .= "\nSET TERM ; ^\n";
2175 }
2176
2177 $this->flush($sql_data);
2178
2179 $db->sql_freeresult($result);
2180 }
2181 }
2182
2183 // get how much space we allow for a chunk of data, very similar to phpMyAdmin's way of doing things ;-) (hey, we only do this for MySQL anyway :P)
2184 function get_usable_memory()
2185 {
2186 $val = trim(@ini_get('memory_limit'));
2187
2188 if (preg_match('/(\\d+)([mkg]?)/i', $val, $regs))
2189 {
2190 $memory_limit = (int) $regs[1];
2191 switch ($regs[2])
2192 {
2193
2194 case 'k':
2195 case 'K':
2196 $memory_limit *= 1024;
2197 break;
2198
2199 case 'm':
2200 case 'M':
2201 $memory_limit *= 1048576;
2202 break;
2203
2204 case 'g':
2205 case 'G':
2206 $memory_limit *= 1073741824;
2207 break;
2208 }
2209
2210 // how much memory PHP requires at the start of export (it is really a little less)
2211 if ($memory_limit > 6100000)
2212 {
2213 $memory_limit -= 6100000;
2214 }
2215
2216 // allow us to consume half of the total memory available
2217 $memory_limit /= 2;
2218 }
2219 else
2220 {
2221 // set the buffer to 1M if we have no clue how much memory PHP will give us :P
2222 $memory_limit = 1048576;
2223 }
2224
2225 return $memory_limit;
2226 }
2227
2228 function sanitize_data_mssql($text)
2229 {
2230 $data = preg_split('/[\n\t\r\b\f]/', $text);
2231 preg_match_all('/[\n\t\r\b\f]/', $text, $matches);
2232
2233 $val = array();
2234
2235 foreach ($data as $value)
2236 {
2237 if (strlen($value))
2238 {
2239 $val[] = "'" . $value . "'";
2240 }
2241 if (sizeof($matches[0]))
2242 {
2243 $val[] = 'char(' . ord(array_shift($matches[0])) . ')';
2244 }
2245 }
2246
2247 return implode('+', $val);
2248 }
2249
2250 function sanitize_data_oracle($text)
2251 {
2252 $data = preg_split('/[\0\n\t\r\b\f\'"\\\]/', $text);
2253 preg_match_all('/[\0\n\t\r\b\f\'"\\\]/', $text, $matches);
2254
2255 $val = array();
2256
2257 foreach ($data as $value)
2258 {
2259 if (strlen($value))
2260 {
2261 $val[] = "'" . $value . "'";
2262 }
2263 if (sizeof($matches[0]))
2264 {
2265 $val[] = 'chr(' . ord(array_shift($matches[0])) . ')';
2266 }
2267 }
2268
2269 return implode('||', $val);
2270 }
2271
2272 function sanitize_data_generic($text)
2273 {
2274 $data = preg_split('/[\n\t\r\b\f]/', $text);
2275 preg_match_all('/[\n\t\r\b\f]/', $text, $matches);
2276
2277 $val = array();
2278
2279 foreach ($data as $value)
2280 {
2281 if (strlen($value))
2282 {
2283 $val[] = "'" . $value . "'";
2284 }
2285 if (sizeof($matches[0]))
2286 {
2287 $val[] = "'" . array_shift($matches[0]) . "'";
2288 }
2289 }
2290
2291 return implode('||', $val);
2292 }
2293
2294 // modified from PHP.net
2295 function fgetd(&$fp, $delim, $read, $seek, $eof, $buffer = 8192)
2296 {
2297 $record = '';
2298 $delim_len = strlen($delim);
2299
2300 while (!$eof($fp))
2301 {
2302 $pos = strpos($record, $delim);
2303 if ($pos === false)
2304 {
2305 $record .= $read($fp, $buffer);
2306 if ($eof($fp) && ($pos = strpos($record, $delim)) !== false)
2307 {
2308 $seek($fp, $pos + $delim_len - strlen($record), SEEK_CUR);
2309 return substr($record, 0, $pos);
2310 }
2311 }
2312 else
2313 {
2314 $seek($fp, $pos + $delim_len - strlen($record), SEEK_CUR);
2315 return substr($record, 0, $pos);
2316 }
2317 }
2318
2319 return false;
2320 }
2321
2322 function fgetd_seekless(&$fp, $delim, $read, $seek, $eof, $buffer = 8192)
2323 {
2324 static $array = array();
2325 static $record = '';
2326
2327 if (!sizeof($array))
2328 {
2329 while (!$eof($fp))
2330 {
2331 if (strpos($record, $delim) !== false)
2332 {
2333 $array = explode($delim, $record);
2334 $record = array_pop($array);
2335 break;
2336 }
2337 else
2338 {
2339 $record .= $read($fp, $buffer);
2340 }
2341 }
2342 if ($eof($fp) && strpos($record, $delim) !== false)
2343 {
2344 $array = explode($delim, $record);
2345 $record = array_pop($array);
2346 }
2347 }
2348
2349 if (sizeof($array))
2350 {
2351 return array_shift($array);
2352 }
2353
2354 return false;
2355 }
2356
2357 ?>
phpbb is a php-based BBS (buletin board system)