simpletool 0.0.1 → 0.0.2

data/lib/support/phpmyadmin/phpmyadmin/libraries/export.lib.php

@@ -0,0 +1,858 @@
+<?php
+
+/* vim: set expandtab sw=4 ts=4 sts=4: */
+/**
+ * function for the main export logic
+ *
+ * @package PhpMyAdmin
+ */
+
+if (! defined('PHPMYADMIN')) {
+    exit;
+}
+
+/**
+ * Sets a session variable upon a possible fatal error during export
+ *
+ * @return void
+ */
+function PMA_shutdownDuringExport()
+{
+    $a = error_get_last();
+    if ($a != null
+        && /*overload*/mb_strpos($a['message'], "execution time")
+    ) {
+        //write in partially downloaded file for future reference of user
+        print_r($a);
+        //set session variable to check if there was error while exporting
+        $_SESSION['pma_export_error'] = $a['message'];
+    }
+}
+
+/**
+ * Detect ob_gzhandler
+ *
+ * @return bool
+ */
+function PMA_isGzHandlerEnabled()
+{
+    return in_array('ob_gzhandler', ob_list_handlers());
+}
+
+/**
+ * Detect whether gzencode is needed; it might not be needed if
+ * the server is already compressing by itself
+ *
+ * @return bool Whether gzencode is needed
+ */
+function PMA_gzencodeNeeded()
+{
+    /*
+     * We should gzencode only if the function exists
+     * but we don't want to compress twice, therefore
+     * gzencode only if transparent compression is not enabled
+     * and gz compression was not asked via $cfg['OBGzip']
+     * but transparent compression does not apply when saving to server
+     */
+    if (@function_exists('gzencode')
+        && ((! @ini_get('zlib.output_compression')
+        && ! PMA_isGzHandlerEnabled())
+        || $GLOBALS['save_on_server'])
+    ) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+/**
+ * Output handler for all exports, if needed buffering, it stores data into
+ * $dump_buffer, otherwise it prints them out.
+ *
+ * @param string $line the insert statement
+ *
+ * @return bool Whether output succeeded
+ */
+function PMA_exportOutputHandler($line)
+{
+    global $time_start, $dump_buffer, $dump_buffer_len, $save_filename;
+
+    // Kanji encoding convert feature
+    if ($GLOBALS['output_kanji_conversion']) {
+        $line = PMA_Kanji_strConv(
+            $line,
+            $GLOBALS['knjenc'],
+            isset($GLOBALS['xkana']) ? $GLOBALS['xkana'] : ''
+        );
+    }
+
+    // If we have to buffer data, we will perform everything at once at the end
+    if ($GLOBALS['buffer_needed']) {
+
+        $dump_buffer .= $line;
+        if ($GLOBALS['onfly_compression']) {
+
+            $dump_buffer_len += /*overload*/mb_strlen($line);
+
+            if ($dump_buffer_len > $GLOBALS['memory_limit']) {
+                if ($GLOBALS['output_charset_conversion']) {
+                    $dump_buffer = PMA_convertString(
+                        'utf-8',
+                        $GLOBALS['charset_of_file'],
+                        $dump_buffer
+                    );
+                }
+                if ($GLOBALS['compression'] == 'gzip'
+                    && PMA_gzencodeNeeded()
+                ) {
+                    // as a gzipped file
+                    // without the optional parameter level because it bugs
+                    $dump_buffer = gzencode($dump_buffer);
+                }
+                if ($GLOBALS['save_on_server']) {
+                    $write_result = @fwrite($GLOBALS['file_handle'], $dump_buffer);
+                    // Here, use strlen rather than mb_strlen to get the length
+                    // in bytes to compare against the number of bytes written.
+                    if ($write_result != strlen($dump_buffer)) {
+                        $GLOBALS['message'] = PMA_Message::error(
+                            __('Insufficient space to save the file %s.')
+                        );
+                        $GLOBALS['message']->addParam($save_filename);
+                        return false;
+                    }
+                } else {
+                    echo $dump_buffer;
+                }
+                $dump_buffer = '';
+                $dump_buffer_len = 0;
+            }
+        } else {
+            $time_now = time();
+            if ($time_start >= $time_now + 30) {
+                $time_start = $time_now;
+                header('X-pmaPing: Pong');
+            } // end if
+        }
+    } else {
+        if ($GLOBALS['asfile']) {
+            if ($GLOBALS['output_charset_conversion']) {
+                $line = PMA_convertString(
+                    'utf-8',
+                    $GLOBALS['charset_of_file'],
+                    $line
+                );
+            }
+            if ($GLOBALS['save_on_server'] && /*overload*/mb_strlen($line) > 0) {
+                $write_result = @fwrite($GLOBALS['file_handle'], $line);
+                // Here, use strlen rather than mb_strlen to get the length
+                // in bytes to compare against the number of bytes written.
+                if (! $write_result
+                    || $write_result != strlen($line)
+                ) {
+                    $GLOBALS['message'] = PMA_Message::error(
+                        __('Insufficient space to save the file %s.')
+                    );
+                    $GLOBALS['message']->addParam($save_filename);
+                    return false;
+                }
+                $time_now = time();
+                if ($time_start >= $time_now + 30) {
+                    $time_start = $time_now;
+                    header('X-pmaPing: Pong');
+                } // end if
+            } else {
+                // We export as file - output normally
+                echo $line;
+            }
+        } else {
+            // We export as html - replace special chars
+            echo htmlspecialchars($line);
+        }
+    }
+    return true;
+} // end of the 'PMA_exportOutputHandler()' function
+
+/**
+ * Returns HTML containing the footer for a displayed export
+ *
+ * @param string $back_button the link for going Back
+ *
+ * @return string $html the HTML output
+ */
+function PMA_getHtmlForDisplayedExportFooter($back_button)
+{
+    /**
+     * Close the html tags and add the footers for on-screen export
+     */
+    $html = '</textarea>'
+        . '    </form>'
+        // bottom back button
+        . $back_button
+        . '</div>'
+        . '<script type="text/javascript">' . "\n"
+        . '//<![CDATA[' . "\n"
+        . 'var $body = $("body");' . "\n"
+        . '$("#textSQLDUMP")' . "\n"
+        . '.width($body.width() - 50)' . "\n"
+        . '.height($body.height() - 100);' . "\n"
+        . '//]]>' . "\n"
+        . '</script>' . "\n";
+    return $html;
+}
+
+/**
+ * Computes the memory limit for export
+ *
+ * @return int $memory_limit the memory limit
+ */
+function PMA_getMemoryLimitForExport()
+{
+    $memory_limit = trim(@ini_get('memory_limit'));
+    $memory_limit_num = (int)substr($memory_limit, 0, -1);
+    $lowerLastChar = strtolower(substr($memory_limit, -1));
+    // 2 MB as default
+    if (empty($memory_limit) || '-1' == $memory_limit) {
+        $memory_limit = 2 * 1024 * 1024;
+    } elseif ($lowerLastChar == 'm') {
+        $memory_limit = $memory_limit_num * 1024 * 1024;
+    } elseif ($lowerLastChar == 'k') {
+        $memory_limit = $memory_limit_num * 1024;
+    } elseif ($lowerLastChar == 'g') {
+        $memory_limit = $memory_limit_num * 1024 * 1024 * 1024;
+    } else {
+        $memory_limit = (int)$memory_limit;
+    }
+
+    // Some of memory is needed for other things and as threshold.
+    // During export I had allocated (see memory_get_usage function)
+    // approx 1.2MB so this comes from that.
+    if ($memory_limit > 1500000) {
+        $memory_limit -= 1500000;
+    }
+
+    // Some memory is needed for compression, assume 1/3
+    $memory_limit /= 8;
+    return $memory_limit;
+}
+
+/**
+ * Return the filename and MIME type for export file
+ *
+ * @param string $export_type       type of export
+ * @param string $remember_template whether to remember template
+ * @param object $export_plugin     the export plugin
+ * @param string $compression       compression asked
+ * @param string $filename_template the filename template
+ *
+ * @return array the filename template and mime type
+ */
+function PMA_getExportFilenameAndMimetype(
+    $export_type, $remember_template, $export_plugin, $compression,
+    $filename_template
+) {
+    if ($export_type == 'server') {
+        if (! empty($remember_template)) {
+            $GLOBALS['PMA_Config']->setUserValue(
+                'pma_server_filename_template',
+                'Export/file_template_server',
+                $filename_template
+            );
+        }
+    } elseif ($export_type == 'database') {
+        if (! empty($remember_template)) {
+            $GLOBALS['PMA_Config']->setUserValue(
+                'pma_db_filename_template',
+                'Export/file_template_database',
+                $filename_template
+            );
+        }
+    } else {
+        if (! empty($remember_template)) {
+            $GLOBALS['PMA_Config']->setUserValue(
+                'pma_table_filename_template',
+                'Export/file_template_table',
+                $filename_template
+            );
+        }
+    }
+    $filename = PMA_Util::expandUserString($filename_template);
+    // remove dots in filename (coming from either the template or already
+    // part of the filename) to avoid a remote code execution vulnerability
+    $filename = PMA_sanitizeFilename($filename, $replaceDots = true);
+
+    // Grab basic dump extension and mime type
+    // Check if the user already added extension;
+    // get the substring where the extension would be if it was included
+    $extension_start_pos = /*overload*/mb_strlen($filename) - /*overload*/mb_strlen(
+        $export_plugin->getProperties()->getExtension()
+    ) - 1;
+    $user_extension = /*overload*/mb_substr(
+        $filename, $extension_start_pos, /*overload*/mb_strlen($filename)
+    );
+    $required_extension = "." . $export_plugin->getProperties()->getExtension();
+    if (/*overload*/mb_strtolower($user_extension) != $required_extension) {
+        $filename  .= $required_extension;
+    }
+    $mime_type  = $export_plugin->getProperties()->getMimeType();
+
+    // If dump is going to be compressed, set correct mime_type and add
+    // compression to extension
+    if ($compression == 'gzip') {
+        $filename  .= '.gz';
+        $mime_type = 'application/x-gzip';
+    } elseif ($compression == 'zip') {
+        $filename  .= '.zip';
+        $mime_type = 'application/zip';
+    }
+    return array($filename, $mime_type);
+}
+
+/**
+ * Open the export file
+ *
+ * @param string  $filename     the export filename
+ * @param boolean $quick_export whether it's a quick export or not
+ *
+ * @return array the full save filename, possible message and the file handle
+ */
+function PMA_openExportFile($filename, $quick_export)
+{
+    $file_handle = null;
+    $message = '';
+
+    $save_filename = PMA_Util::userDir($GLOBALS['cfg']['SaveDir'])
+        . preg_replace('@[/\\\\]@', '_', $filename);
+
+    if (file_exists($save_filename)
+        && ((! $quick_export && empty($_REQUEST['onserverover']))
+        || ($quick_export
+        && $_REQUEST['quick_export_onserverover'] != 'saveitover'))
+    ) {
+        $message = PMA_Message::error(
+            __(
+                'File %s already exists on server, '
+                . 'change filename or check overwrite option.'
+            )
+        );
+        $message->addParam($save_filename);
+    } elseif (is_file($save_filename) && ! is_writable($save_filename)) {
+        $message = PMA_Message::error(
+            __(
+                'The web server does not have permission '
+                . 'to save the file %s.'
+            )
+        );
+        $message->addParam($save_filename);
+    } elseif (! $file_handle = @fopen($save_filename, 'w')) {
+        $message = PMA_Message::error(
+            __(
+                'The web server does not have permission '
+                . 'to save the file %s.'
+            )
+        );
+        $message->addParam($save_filename);
+    }
+    return array($save_filename, $message, $file_handle);
+}
+
+/**
+ * Close the export file
+ *
+ * @param resource $file_handle   the export file handle
+ * @param string   $dump_buffer   the current dump buffer
+ * @param string   $save_filename the export filename
+ *
+ * @return object $message a message object (or empty string)
+ */
+function PMA_closeExportFile($file_handle, $dump_buffer, $save_filename)
+{
+    $write_result = @fwrite($file_handle, $dump_buffer);
+    fclose($file_handle);
+    // Here, use strlen rather than mb_strlen to get the length
+    // in bytes to compare against the number of bytes written.
+    if (/*overload*/mb_strlen($dump_buffer) > 0
+        && (! $write_result || $write_result != strlen($dump_buffer))
+    ) {
+        $message = new PMA_Message(
+            __('Insufficient space to save the file %s.'),
+            PMA_Message::ERROR,
+            array($save_filename)
+        );
+    } else {
+        $message = new PMA_Message(
+            __('Dump has been saved to file %s.'),
+            PMA_Message::SUCCESS,
+            array($save_filename)
+        );
+    }
+    return $message;
+}
+
+/**
+ * Compress the export buffer
+ *
+ * @param string $dump_buffer the current dump buffer
+ * @param string $compression the compression mode
+ * @param string $filename    the filename
+ *
+ * @return object $message a message object (or empty string)
+ */
+function PMA_compressExport($dump_buffer, $compression, $filename)
+{
+    if ($compression == 'zip' && @function_exists('gzcompress')) {
+        $zipfile = new ZipFile();
+        $zipfile->addFile(
+            $dump_buffer,
+            substr($filename, 0, -4)
+        );
+        $dump_buffer = $zipfile->file();
+    } elseif ($compression == 'gzip' && PMA_gzencodeNeeded()) {
+        // without the optional parameter level because it bugs
+        $dump_buffer = gzencode($dump_buffer);
+    }
+    return $dump_buffer;
+}
+
+/**
+ * Returns HTML containing the header for a displayed export
+ *
+ * @param string $export_type the export type
+ * @param string $db          the database name
+ * @param string $table       the table name
+ *
+ * @return array the generated HTML and back button
+ */
+function PMA_getHtmlForDisplayedExportHeader($export_type, $db, $table)
+{
+    $html = '<div style="text-align: ' . $GLOBALS['cell_align_left'] . '">';
+
+    /**
+     * Displays a back button with all the $_REQUEST data in the URL
+     * (store in a variable to also display after the textarea)
+     */
+    $back_button = '<p>[ <a href="';
+    if ($export_type == 'server') {
+        $back_button .= 'server_export.php' . PMA_URL_getCommon();
+    } elseif ($export_type == 'database') {
+        $back_button .= 'db_export.php' . PMA_URL_getCommon(array('db' => $db));
+    } else {
+        $back_button .= 'tbl_export.php' . PMA_URL_getCommon(
+            array(
+                'db' => $db, 'table' => $table
+            )
+        );
+    }
+
+    // Convert the multiple select elements from an array to a string
+    if ($export_type == 'server' && isset($_REQUEST['db_select'])) {
+        $_REQUEST['db_select'] = implode(",", $_REQUEST['db_select']);
+    } elseif ($export_type == 'database'
+        && isset($_REQUEST['table_select'])
+    ) {
+        $_REQUEST['table_select'] = implode(",", $_REQUEST['table_select']);
+    }
+
+    foreach ($_REQUEST as $name => $value) {
+        if (!is_array($value)) {
+            $back_button .= '&amp;' . urlencode($name) . '=' . urlencode($value);
+        }
+    }
+    $back_button .= '&amp;repopulate=1">' . __('Back') . '</a> ]</p>';
+
+    $html .= $back_button
+        . '<form name="nofunction">'
+        . '<textarea name="sqldump" cols="50" rows="30" '
+        . 'id="textSQLDUMP" wrap="OFF">';
+
+    return array($html, $back_button);
+}
+
+/**
+ * Export at the server level
+ *
+ * @param string $db_select       the selected databases to export
+ * @param string $whatStrucOrData structure or data or both
+ * @param object $export_plugin   the selected export plugin
+ * @param string $crlf            end of line character(s)
+ * @param string $err_url         the URL in case of error
+ * @param string $export_type     the export type
+ * @param bool   $do_relation     whether to export relation info
+ * @param bool   $do_comments     whether to add comments
+ * @param bool   $do_mime         whether to add MIME info
+ * @param bool   $do_dates        whether to add dates
+ * @param array  $aliases         Alias information for db/table/column
+ *
+ * @return void
+ */
+function PMA_exportServer(
+    $db_select, $whatStrucOrData, $export_plugin, $crlf, $err_url,
+    $export_type, $do_relation, $do_comments, $do_mime, $do_dates,
+    $aliases
+) {
+    if (! empty($db_select)) {
+        $tmp_select = implode($db_select, '|');
+        $tmp_select = '|' . $tmp_select . '|';
+    }
+    // Walk over databases
+    foreach ($GLOBALS['pma']->databases as $current_db) {
+        if (isset($tmp_select)
+            && /*overload*/mb_strpos(' ' . $tmp_select, '|' . $current_db . '|')
+        ) {
+            $tables = $GLOBALS['dbi']->getTables($current_db);
+            PMA_exportDatabase(
+                $current_db, $tables, $whatStrucOrData, $export_plugin, $crlf,
+                $err_url, $export_type, $do_relation, $do_comments, $do_mime,
+                $do_dates, $aliases
+            );
+        }
+    } // end foreach database
+}
+
+/**
+ * Export at the database level
+ *
+ * @param string $db              the database to export
+ * @param array  $tables          the tables to export
+ * @param string $whatStrucOrData structure or data or both
+ * @param object $export_plugin   the selected export plugin
+ * @param string $crlf            end of line character(s)
+ * @param string $err_url         the URL in case of error
+ * @param string $export_type     the export type
+ * @param bool   $do_relation     whether to export relation info
+ * @param bool   $do_comments     whether to add comments
+ * @param bool   $do_mime         whether to add MIME info
+ * @param bool   $do_dates        whether to add dates
+ * @param array  $aliases         Alias information for db/table/column
+ *
+ * @return void
+ */
+function PMA_exportDatabase(
+    $db, $tables, $whatStrucOrData, $export_plugin, $crlf, $err_url,
+    $export_type, $do_relation, $do_comments, $do_mime, $do_dates,
+    $aliases
+) {
+    $db_alias = !empty($aliases[$db]['alias'])
+        ? $aliases[$db]['alias'] : '';
+    if (! $export_plugin->exportDBHeader($db, $db_alias)) {
+        return;
+    }
+    if (! $export_plugin->exportDBCreate($db, $db_alias)) {
+        return;
+    }
+
+    if (method_exists($export_plugin, 'exportRoutines')
+        && /*overload*/mb_strpos(
+            $GLOBALS['sql_structure_or_data'],
+            'structure'
+        ) !== false
+        && isset($GLOBALS['sql_procedure_function'])
+    ) {
+        $export_plugin->exportRoutines($db, $aliases);
+    }
+
+    $views = array();
+
+    foreach ($tables as $table) {
+        // if this is a view, collect it for later;
+        // views must be exported after the tables
+        $is_view = PMA_Table::isView($db, $table);
+        if ($is_view) {
+            $views[] = $table;
+        }
+        if ($whatStrucOrData == 'structure'
+            || $whatStrucOrData == 'structure_and_data'
+        ) {
+            // for a view, export a stand-in definition of the table
+            // to resolve view dependencies
+
+            if ($is_view) {
+
+                if (isset($GLOBALS['sql_create_view'])) {
+                    if (! $export_plugin->exportStructure(
+                        $db, $table, $crlf, $err_url, 'stand_in',
+                        $export_type, $do_relation, $do_comments,
+                        $do_mime, $do_dates, $aliases
+                    )) {
+                        break 1;
+                    }
+                }
+
+            } else if (isset($GLOBALS['sql_create_table'])) {
+
+                $table_size = $GLOBALS['maxsize'];
+                // Checking if the maximum table size constrain has been set
+                // And if that constrain is a valid number or not
+                if ($table_size !== '' && is_numeric($table_size)) {
+                    // This obtains the current table's size
+                    $query = 'SELECT data_length + index_length
+                          from information_schema.TABLES
+                          WHERE table_schema = "' . $db . '"
+                          AND table_name = "' . $table . '"';
+
+                    $size = $GLOBALS['dbi']->fetchValue($query);
+                    //Converting the size to MB
+                    $size = ($size / 1024) / 1024;
+                    if ($size > $table_size) {
+                        continue;
+                    }
+                }
+
+                if (! $export_plugin->exportStructure(
+                    $db, $table, $crlf, $err_url, 'create_table',
+                    $export_type, $do_relation, $do_comments,
+                    $do_mime, $do_dates, $aliases
+                )) {
+                    break 1;
+                }
+
+            }
+
+        }
+        // if this is a view or a merge table, don't export data
+        if (($whatStrucOrData == 'data'
+            || $whatStrucOrData == 'structure_and_data')
+            && ! ($is_view || PMA_Table::isMerge($db, $table))
+        ) {
+            $local_query  = 'SELECT * FROM ' . PMA_Util::backquote($db)
+                . '.' . PMA_Util::backquote($table);
+            if (! $export_plugin->exportData(
+                $db, $table, $crlf, $err_url, $local_query, $aliases
+            )) {
+                break 1;
+            }
+        }
+        // now export the triggers (needs to be done after the data because
+        // triggers can modify already imported tables)
+        if (isset($GLOBALS['sql_create_trigger']) && ($whatStrucOrData == 'structure'
+            || $whatStrucOrData == 'structure_and_data')
+        ) {
+            if (! $export_plugin->exportStructure(
+                $db, $table, $crlf, $err_url, 'triggers',
+                $export_type, $do_relation, $do_comments,
+                $do_mime, $do_dates, $aliases
+            )) {
+                break 1;
+            }
+        }
+    }
+
+    if (isset($GLOBALS['sql_create_view'])) {
+
+        foreach ($views as $view) {
+            // no data export for a view
+            if ($whatStrucOrData == 'structure'
+                || $whatStrucOrData == 'structure_and_data'
+            ) {
+                if (! $export_plugin->exportStructure(
+                    $db, $view, $crlf, $err_url, 'create_view',
+                    $export_type, $do_relation, $do_comments,
+                    $do_mime, $do_dates, $aliases
+                )) {
+                    break 1;
+                }
+            }
+        }
+
+    }
+
+    if (! $export_plugin->exportDBFooter($db, $db_alias)) {
+        return;
+    }
+}
+
+/**
+ * Export at the table level
+ *
+ * @param string $db              the database to export
+ * @param string $table           the table to export
+ * @param string $whatStrucOrData structure or data or both
+ * @param object $export_plugin   the selected export plugin
+ * @param string $crlf            end of line character(s)
+ * @param string $err_url         the URL in case of error
+ * @param string $export_type     the export type
+ * @param bool   $do_relation     whether to export relation info
+ * @param bool   $do_comments     whether to add comments
+ * @param bool   $do_mime         whether to add MIME info
+ * @param bool   $do_dates        whether to add dates
+ * @param string $allrows         whether "dump all rows" was ticked
+ * @param string $limit_to        upper limit
+ * @param string $limit_from      starting limit
+ * @param string $sql_query       query for which exporting is requested
+ * @param array  $aliases         Alias information for db/table/column
+ *
+ * @return void
+ */
+function PMA_exportTable(
+    $db, $table, $whatStrucOrData, $export_plugin, $crlf, $err_url,
+    $export_type, $do_relation, $do_comments, $do_mime, $do_dates,
+    $allrows, $limit_to, $limit_from, $sql_query, $aliases
+) {
+    $db_alias = !empty($aliases[$db]['alias'])
+        ? $aliases[$db]['alias'] : '';
+    if (! $export_plugin->exportDBHeader($db, $db_alias)) {
+        return;
+    }
+    if (isset($allrows)
+        && $allrows == '0'
+        && $limit_to > 0
+        && $limit_from >= 0
+    ) {
+        $add_query  = ' LIMIT '
+                    . (($limit_from > 0) ? $limit_from . ', ' : '')
+                    . $limit_to;
+    } else {
+        $add_query  = '';
+    }
+
+    $is_view = PMA_Table::isView($db, $table);
+    if ($whatStrucOrData == 'structure'
+        || $whatStrucOrData == 'structure_and_data'
+    ) {
+
+        if ($is_view) {
+
+            if (isset($GLOBALS['sql_create_view'])) {
+                if (! $export_plugin->exportStructure(
+                    $db, $table, $crlf, $err_url, 'create_view',
+                    $export_type, $do_relation, $do_comments,
+                    $do_mime, $do_dates, $aliases
+                )) {
+                    return;
+                }
+            }
+
+        } else if (isset($GLOBALS['sql_create_table'])) {
+
+            if (! $export_plugin->exportStructure(
+                $db, $table, $crlf, $err_url, 'create_table',
+                $export_type, $do_relation, $do_comments,
+                $do_mime, $do_dates, $aliases
+            )) {
+                return;
+            }
+
+        }
+
+    }
+    // If this is an export of a single view, we have to export data;
+    // for example, a PDF report
+    // if it is a merge table, no data is exported
+    if (($whatStrucOrData == 'data'
+        || $whatStrucOrData == 'structure_and_data')
+        && ! PMA_Table::isMerge($db, $table)
+    ) {
+        if (! empty($sql_query)) {
+            // only preg_replace if needed
+            if (! empty($add_query)) {
+                // remove trailing semicolon before adding a LIMIT
+                $sql_query = preg_replace('%;\s*$%', '', $sql_query);
+            }
+            $local_query = $sql_query . $add_query;
+            $GLOBALS['dbi']->selectDb($db);
+        } else {
+            $local_query  = 'SELECT * FROM ' . PMA_Util::backquote($db)
+                . '.' . PMA_Util::backquote($table) . $add_query;
+        }
+        if (! $export_plugin->exportData(
+            $db, $table, $crlf, $err_url, $local_query, $aliases
+        )) {
+            return;
+        }
+    }
+    // now export the triggers (needs to be done after the data because
+    // triggers can modify already imported tables)
+    if (isset($GLOBALS['sql_create_trigger']) && ($whatStrucOrData == 'structure'
+        || $whatStrucOrData == 'structure_and_data')
+    ) {
+        if (! $export_plugin->exportStructure(
+            $db, $table, $crlf, $err_url, 'triggers',
+            $export_type, $do_relation, $do_comments,
+            $do_mime, $do_dates, $aliases
+        )) {
+            return;
+        }
+    }
+    if (! $export_plugin->exportDBFooter($db, $db_alias)) {
+        return;
+    }
+}
+
+/**
+ * Loads correct page after doing export
+ *
+ * @param string $db          the database name
+ * @param string $table       the table name
+ * @param string $export_type Export type
+ *
+ * @return void
+ */
+function PMA_showExportPage($db, $table, $export_type)
+{
+    global $cfg;
+    if ($export_type == 'server') {
+        $active_page = 'server_export.php';
+        include_once 'server_export.php';
+    } elseif ($export_type == 'database') {
+        $active_page = 'db_export.php';
+        include_once 'db_export.php';
+    } else {
+        $active_page = 'tbl_export.php';
+        include_once 'tbl_export.php';
+    }
+    exit();
+}
+
+/**
+ * Merge two alias arrays, if array1 and array2 have
+ * conflicting alias then array2 value is used if it
+ * is non empty otherwise array1 value.
+ *
+ * @param array $aliases1 first array of aliases
+ * @param array $aliases2 second array of aliases
+ *
+ * @return array resultant merged aliases info
+ */
+function PMA_mergeAliases($aliases1, $aliases2)
+{
+    // First do a recursive array merge
+    // on aliases arrays.
+    $aliases = array_merge_recursive($aliases1, $aliases2);
+    // Now, resolve conflicts in aliases, if any
+    foreach ($aliases as $db_name => $db) {
+        // If alias key is an array then
+        // it is a merge conflict.
+        if (isset($db['alias']) && is_array($db['alias'])) {
+            $val1 = $db['alias'][0];
+            $val2 = $db['alias'][1];
+            // Use aliases2 alias if non empty
+            $aliases[$db_name]['alias']
+                = empty($val2) ? $val1 : $val2;
+        }
+        if (!isset($db['tables'])) {
+            continue;
+        }
+        foreach ($db['tables'] as $tbl_name => $tbl) {
+            if (isset($tbl['alias']) && is_array($tbl['alias'])) {
+                $val1 = $tbl['alias'][0];
+                $val2 = $tbl['alias'][1];
+                // Use aliases2 alias if non empty
+                $aliases[$db_name]['tables'][$tbl_name]['alias']
+                    = empty($val2) ? $val1 : $val2;
+            }
+            if (!isset($tbl['columns'])) {
+                continue;
+            }
+            foreach ($tbl['columns'] as  $col => $col_as) {
+                if (isset($col_as) && is_array($col_as)) {
+                    $val1 = $col_as[0];
+                    $val2 = $col_as[1];
+                    // Use aliases2 alias if non empty
+                    $aliases[$db_name]['tables'][$tbl_name]['columns'][$col]
+                        = empty($val2) ? $val1 : $val2;
+                }
+            };
+        };
+    }
+    return $aliases;
+}
+?>