import.php

   1 <?php
   2 /* vim: set expandtab sw=4 ts=4 sts=4: */
   3 /**
   4  * Core script for import, this is just the glue around all other stuff
   5  *
   6  * @package PhpMyAdmin
   7  */
   8 declare(strict_types=1);
   9
  10 use PhpMyAdmin\Bookmark;
  11 use PhpMyAdmin\Core;
  12 use PhpMyAdmin\DatabaseInterface;
  13 use PhpMyAdmin\Encoding;
  14 use PhpMyAdmin\File;
  15 use PhpMyAdmin\Import;
  16 use PhpMyAdmin\ParseAnalyze;
  17 use PhpMyAdmin\Plugins;
  18 use PhpMyAdmin\Plugins\ImportPlugin;
  19 use PhpMyAdmin\Response;
  20 use PhpMyAdmin\Sql;
  21 use PhpMyAdmin\Url;
  22 use PhpMyAdmin\Util;
  23
  24 if (! defined('ROOT_PATH')) {
  25     define('ROOT_PATH', __DIR__ . DIRECTORY_SEPARATOR);
  26 }
  27
  28 /* Enable LOAD DATA LOCAL INFILE for LDI plugin */
  29 if (isset($_POST['format']) && $_POST['format'] == 'ldi') {
  30     define('PMA_ENABLE_LDI', 1);
  31 }
  32
  33 global $db, $pmaThemeImage, $table;
  34
  35 require_once ROOT_PATH . 'libraries/common.inc.php';
  36
  37 /** @var Response $response */
  38 $response = $containerBuilder->get(Response::class);
  39
  40 /** @var DatabaseInterface $dbi */
  41 $dbi = $containerBuilder->get(DatabaseInterface::class);
  42
  43 /** @var import $import */
  44 $import = $containerBuilder->get('import');
  45
  46 if (isset($_POST['show_as_php'])) {
  47     $GLOBALS['show_as_php'] = $_POST['show_as_php'];
  48 }
  49
  50 // If there is a request to 'Simulate DML'.
  51 if (isset($_POST['simulate_dml'])) {
  52     $import->handleSimulateDmlRequest();
  53     exit;
  54 }
  55
  56 $sql = new Sql();
  57
  58 // If it's a refresh console bookmarks request
  59 if (isset($_GET['console_bookmark_refresh'])) {
  60     $response->addJSON(
  61         'console_message_bookmark',
  62         PhpMyAdmin\Console::getBookmarkContent()
  63     );
  64     exit;
  65 }
  66 // If it's a console bookmark add request
  67 if (isset($_POST['console_bookmark_add'])) {
  68     if (isset($_POST['label']) && isset($_POST['db'])
  69         && isset($_POST['bookmark_query']) && isset($_POST['shared'])
  70     ) {
  71         $cfgBookmark = Bookmark::getParams($GLOBALS['cfg']['Server']['user']);
  72         $bookmarkFields = [
  73             'bkm_database' => $_POST['db'],
  74             'bkm_user'  => $cfgBookmark['user'],
  75             'bkm_sql_query' => $_POST['bookmark_query'],
  76             'bkm_label' => $_POST['label'],
  77         ];
  78         $isShared = ($_POST['shared'] == 'true' ? true : false);
  79         $bookmark = Bookmark::createBookmark(
  80             $dbi,
  81             $GLOBALS['cfg']['Server']['user'],
  82             $bookmarkFields,
  83             $isShared
  84         );
  85         if ($bookmark !== false && $bookmark->save()) {
  86             $response->addJSON('message', __('Succeeded'));
  87             $response->addJSON('data', $bookmarkFields);
  88             $response->addJSON('isShared', $isShared);
  89         } else {
  90             $response->addJSON('message', __('Failed'));
  91         }
  92         die();
  93     } else {
  94         $response->addJSON('message', __('Incomplete params'));
  95         die();
  96     }
  97 }
  98
  99 $format = '';
 100
 101 /**
 102  * Sets globals from $_POST
 103  */
 104 $post_params = [
 105     'charset_of_file',
 106     'format',
 107     'import_type',
 108     'is_js_confirmed',
 109     'MAX_FILE_SIZE',
 110     'message_to_show',
 111     'noplugin',
 112     'skip_queries',
 113     'local_import_file',
 114 ];
 115
 116 foreach ($post_params as $one_post_param) {
 117     if (isset($_POST[$one_post_param])) {
 118         $GLOBALS[$one_post_param] = $_POST[$one_post_param];
 119     }
 120 }
 121
 122 // reset import messages for ajax request
 123 $_SESSION['Import_message']['message'] = null;
 124 $_SESSION['Import_message']['go_back_url'] = null;
 125 // default values
 126 $GLOBALS['reload'] = false;
 127
 128 // Use to identify current cycle is executing
 129 // a multiquery statement or stored routine
 130 if (! isset($_SESSION['is_multi_query'])) {
 131     $_SESSION['is_multi_query'] = false;
 132 }
 133
 134 $ajax_reload = [];
 135 $import_text = '';
 136 // Are we just executing plain query or sql file?
 137 // (eg. non import, but query box/window run)
 138 if (! empty($sql_query)) {
 139     // apply values for parameters
 140     if (! empty($_POST['parameterized'])
 141         && ! empty($_POST['parameters'])
 142         && is_array($_POST['parameters'])
 143     ) {
 144         $parameters = $_POST['parameters'];
 145         foreach ($parameters as $parameter => $replacement) {
 146             $quoted = preg_quote($parameter, '/');
 147             // making sure that :param does not apply values to :param1
 148             $sql_query = preg_replace(
 149                 '/' . $quoted . '([^a-zA-Z0-9_])/',
 150                 $dbi->escapeString($replacement) . '${1}',
 151                 $sql_query
 152             );
 153             // for parameters the appear at the end of the string
 154             $sql_query = preg_replace(
 155                 '/' . $quoted . '$/',
 156                 $dbi->escapeString($replacement),
 157                 $sql_query
 158             );
 159         }
 160     }
 161
 162     // run SQL query
 163     $import_text = $sql_query;
 164     $import_type = 'query';
 165     $format = 'sql';
 166     $_SESSION['sql_from_query_box'] = true;
 167
 168     // If there is a request to ROLLBACK when finished.
 169     if (isset($_POST['rollback_query'])) {
 170         $import->handleRollbackRequest($import_text);
 171     }
 172
 173     // refresh navigation and main panels
 174     if (preg_match('/^(DROP)\s+(VIEW|TABLE|DATABASE|SCHEMA)\s+/i', $sql_query)) {
 175         $GLOBALS['reload'] = true;
 176         $ajax_reload['reload'] = true;
 177     }
 178
 179     // refresh navigation panel only
 180     if (preg_match(
 181         '/^(CREATE|ALTER)\s+(VIEW|TABLE|DATABASE|SCHEMA)\s+/i',
 182         $sql_query
 183     )) {
 184         $ajax_reload['reload'] = true;
 185     }
 186
 187     // do a dynamic reload if table is RENAMED
 188     // (by sending the instruction to the AJAX response handler)
 189     if (preg_match(
 190         '/^RENAME\s+TABLE\s+(.*?)\s+TO\s+(.*?)($|;|\s)/i',
 191         $sql_query,
 192         $rename_table_names
 193     )) {
 194         $ajax_reload['reload'] = true;
 195         $ajax_reload['table_name'] = PhpMyAdmin\Util::unQuote(
 196             $rename_table_names[2]
 197         );
 198     }
 199
 200     $sql_query = '';
 201 } elseif (! empty($sql_file)) {
 202     // run uploaded SQL file
 203     $import_file = $sql_file;
 204     $import_type = 'queryfile';
 205     $format = 'sql';
 206     unset($sql_file);
 207 } elseif (! empty($_POST['id_bookmark'])) {
 208     // run bookmark
 209     $import_type = 'query';
 210     $format = 'sql';
 211 }
 212
 213 // If we didn't get any parameters, either user called this directly, or
 214 // upload limit has been reached, let's assume the second possibility.
 215 if ($_POST == [] && $_GET == []) {
 216     $message = PhpMyAdmin\Message::error(
 217         __(
 218             'You probably tried to upload a file that is too large. Please refer ' .
 219             'to %sdocumentation%s for a workaround for this limit.'
 220         )
 221     );
 222     $message->addParam('[doc@faq1-16]');
 223     $message->addParam('[/doc]');
 224
 225     // so we can obtain the message
 226     $_SESSION['Import_message']['message'] = $message->getDisplay();
 227     $_SESSION['Import_message']['go_back_url'] = $GLOBALS['goto'];
 228
 229     $response->setRequestStatus(false);
 230     $response->addJSON('message', $message);
 231
 232     exit; // the footer is displayed automatically
 233 }
 234
 235 // Add console message id to response output
 236 if (isset($_POST['console_message_id'])) {
 237     $response->addJSON('console_message_id', $_POST['console_message_id']);
 238 }
 239
 240 /**
 241  * Sets globals from $_POST patterns, for import plugins
 242  * We only need to load the selected plugin
 243  */
 244
 245 if (! in_array(
 246     $format,
 247     [
 248         'csv',
 249         'ldi',
 250         'mediawiki',
 251         'ods',
 252         'shp',
 253         'sql',
 254         'xml',
 255     ]
 256 )
 257 ) {
 258     // this should not happen for a normal user
 259     // but only during an attack
 260     Core::fatalError('Incorrect format parameter');
 261 }
 262
 263 $post_patterns = [
 264     '/^force_file_/',
 265     '/^' . $format . '_/',
 266 ];
 267
 268 Core::setPostAsGlobal($post_patterns);
 269
 270 // Check needed parameters
 271 PhpMyAdmin\Util::checkParameters(['import_type', 'format']);
 272
 273 // We don't want anything special in format
 274 $format = Core::securePath($format);
 275
 276 if (strlen($table) > 0 && strlen($db) > 0) {
 277     $urlparams = [
 278         'db' => $db,
 279         'table' => $table,
 280     ];
 281 } elseif (strlen($db) > 0) {
 282     $urlparams = ['db' => $db];
 283 } else {
 284     $urlparams = [];
 285 }
 286
 287 // Create error and goto url
 288 if ($import_type == 'table') {
 289     $goto = 'tbl_import.php';
 290 } elseif ($import_type == 'database') {
 291     $goto = 'db_import.php';
 292 } elseif ($import_type == 'server') {
 293     $goto = 'server_import.php';
 294 } elseif (empty($goto) || ! preg_match('@^(server|db|tbl)(_[a-z]*)*\.php$@i', $goto)) {
 295     if (strlen($table) > 0 && strlen($db) > 0) {
 296         $goto = 'tbl_structure.php';
 297     } elseif (strlen($db) > 0) {
 298         $goto = 'db_structure.php';
 299     } else {
 300         $goto = 'server_sql.php';
 301     }
 302 }
 303 $err_url = $goto . Url::getCommon($urlparams);
 304 $_SESSION['Import_message']['go_back_url'] = $err_url;
 305 // Avoid setting selflink to 'import.php'
 306 // problem similar to bug 4276
 307 if (basename($_SERVER['SCRIPT_NAME']) === 'import.php') {
 308     $_SERVER['SCRIPT_NAME'] = $goto;
 309 }
 310
 311
 312 if (strlen($db) > 0) {
 313     $dbi->selectDb($db);
 314 }
 315
 316 Util::setTimeLimit();
 317 if (! empty($cfg['MemoryLimit'])) {
 318     ini_set('memory_limit', $cfg['MemoryLimit']);
 319 }
 320
 321 $timestamp = time();
 322 if (isset($_POST['allow_interrupt'])) {
 323     $maximum_time = ini_get('max_execution_time');
 324 } else {
 325     $maximum_time = 0;
 326 }
 327
 328 // set default values
 329 $timeout_passed = false;
 330 $error = false;
 331 $read_multiply = 1;
 332 $finished = false;
 333 $offset = 0;
 334 $max_sql_len = 0;
 335 $file_to_unlink = '';
 336 $sql_query = '';
 337 $sql_query_disabled = false;
 338 $go_sql = false;
 339 $executed_queries = 0;
 340 $run_query = true;
 341 $charset_conversion = false;
 342 $reset_charset = false;
 343 $bookmark_created = false;
 344 $result = false;
 345 $msg = 'Sorry an unexpected error happened!';
 346
 347 // Bookmark Support: get a query back from bookmark if required
 348 if (! empty($_POST['id_bookmark'])) {
 349     $id_bookmark = (int) $_POST['id_bookmark'];
 350     switch ($_POST['action_bookmark']) {
 351         case 0: // bookmarked query that have to be run
 352             $bookmark = Bookmark::get(
 353                 $dbi,
 354                 $GLOBALS['cfg']['Server']['user'],
 355                 $db,
 356                 $id_bookmark,
 357                 'id',
 358                 isset($_POST['action_bookmark_all'])
 359             );
 360
 361             if (! empty($_POST['bookmark_variable'])) {
 362                 $import_text = $bookmark->applyVariables(
 363                     $_POST['bookmark_variable']
 364                 );
 365             } else {
 366                 $import_text = $bookmark->getQuery();
 367             }
 368
 369             // refresh navigation and main panels
 370             if (preg_match(
 371                 '/^(DROP)\s+(VIEW|TABLE|DATABASE|SCHEMA)\s+/i',
 372                 $import_text
 373             )) {
 374                 $GLOBALS['reload'] = true;
 375                 $ajax_reload['reload'] = true;
 376             }
 377
 378             // refresh navigation panel only
 379             if (preg_match(
 380                 '/^(CREATE|ALTER)\s+(VIEW|TABLE|DATABASE|SCHEMA)\s+/i',
 381                 $import_text
 382             )
 383             ) {
 384                 $ajax_reload['reload'] = true;
 385             }
 386             break;
 387         case 1: // bookmarked query that have to be displayed
 388             $bookmark = Bookmark::get(
 389                 $dbi,
 390                 $GLOBALS['cfg']['Server']['user'],
 391                 $db,
 392                 $id_bookmark
 393             );
 394             $import_text = $bookmark->getQuery();
 395             if ($response->isAjax()) {
 396                 $message = PhpMyAdmin\Message::success(__('Showing bookmark'));
 397                 $response->setRequestStatus($message->isSuccess());
 398                 $response->addJSON('message', $message);
 399                 $response->addJSON('sql_query', $import_text);
 400                 $response->addJSON('action_bookmark', $_POST['action_bookmark']);
 401                 exit;
 402             } else {
 403                 $run_query = false;
 404             }
 405             break;
 406         case 2: // bookmarked query that have to be deleted
 407             $bookmark = Bookmark::get(
 408                 $dbi,
 409                 $GLOBALS['cfg']['Server']['user'],
 410                 $db,
 411                 $id_bookmark
 412             );
 413             if (! empty($bookmark)) {
 414                 $bookmark->delete();
 415                 if ($response->isAjax()) {
 416                     $message = PhpMyAdmin\Message::success(
 417                         __('The bookmark has been deleted.')
 418                     );
 419                     $response->setRequestStatus($message->isSuccess());
 420                     $response->addJSON('message', $message);
 421                     $response->addJSON('action_bookmark', $_POST['action_bookmark']);
 422                     $response->addJSON('id_bookmark', $id_bookmark);
 423                     exit;
 424                 } else {
 425                     $run_query = false;
 426                     $error = true; // this is kind of hack to skip processing the query
 427                 }
 428             }
 429
 430             break;
 431     }
 432 } // end bookmarks reading
 433
 434 // Do no run query if we show PHP code
 435 if (isset($GLOBALS['show_as_php'])) {
 436     $run_query = false;
 437     $go_sql = true;
 438 }
 439
 440 // We can not read all at once, otherwise we can run out of memory
 441 $memory_limit = trim(ini_get('memory_limit'));
 442 // 2 MB as default
 443 if (empty($memory_limit)) {
 444     $memory_limit = 2 * 1024 * 1024;
 445 }
 446 // In case no memory limit we work on 10MB chunks
 447 if ($memory_limit == -1) {
 448     $memory_limit = 10 * 1024 * 1024;
 449 }
 450
 451 // Calculate value of the limit
 452 $memoryUnit = mb_strtolower(substr((string) $memory_limit, -1));
 453 if ('m' == $memoryUnit) {
 454     $memory_limit = (int) substr((string) $memory_limit, 0, -1) * 1024 * 1024;
 455 } elseif ('k' == $memoryUnit) {
 456     $memory_limit = (int) substr((string) $memory_limit, 0, -1) * 1024;
 457 } elseif ('g' == $memoryUnit) {
 458     $memory_limit = (int) substr((string) $memory_limit, 0, -1) * 1024 * 1024 * 1024;
 459 } else {
 460     $memory_limit = (int) $memory_limit;
 461 }
 462
 463 // Just to be sure, there might be lot of memory needed for uncompression
 464 $read_limit = $memory_limit / 8;
 465
 466 // handle filenames
 467 if (isset($_FILES['import_file'])) {
 468     $import_file = $_FILES['import_file']['tmp_name'];
 469     $import_file_name = $_FILES['import_file']['name'];
 470 }
 471 if (! empty($local_import_file) && ! empty($cfg['UploadDir'])) {
 472     // sanitize $local_import_file as it comes from a POST
 473     $local_import_file = Core::securePath($local_import_file);
 474
 475     $import_file = PhpMyAdmin\Util::userDir($cfg['UploadDir'])
 476         . $local_import_file;
 477
 478     /*
 479      * Do not allow symlinks to avoid security issues
 480      * (user can create symlink to file he can not access,
 481      * but phpMyAdmin can).
 482      */
 483     if (@is_link($import_file)) {
 484         $import_file  = 'none';
 485     }
 486 } elseif (empty($import_file) || ! is_uploaded_file($import_file)) {
 487     $import_file  = 'none';
 488 }
 489
 490 // Do we have file to import?
 491
 492 if ($import_file != 'none' && ! $error) {
 493     /**
 494      *  Handle file compression
 495      */
 496     $import_handle = new File($import_file);
 497     $import_handle->checkUploadedFile();
 498     if ($import_handle->isError()) {
 499         $import->stop($import_handle->getError());
 500     }
 501     $import_handle->setDecompressContent(true);
 502     $import_handle->open();
 503     if ($import_handle->isError()) {
 504         $import->stop($import_handle->getError());
 505     }
 506 } elseif (! $error) {
 507     if (! isset($import_text) || empty($import_text)) {
 508         $message = PhpMyAdmin\Message::error(
 509             __(
 510                 'No data was received to import. Either no file name was ' .
 511                 'submitted, or the file size exceeded the maximum size permitted ' .
 512                 'by your PHP configuration. See [doc@faq1-16]FAQ 1.16[/doc].'
 513             )
 514         );
 515         $import->stop($message);
 516     }
 517 }
 518
 519 // so we can obtain the message
 520 //$_SESSION['Import_message'] = $message->getDisplay();
 521
 522 // Convert the file's charset if necessary
 523 if (Encoding::isSupported() && isset($charset_of_file)) {
 524     if ($charset_of_file != 'utf-8') {
 525         $charset_conversion = true;
 526     }
 527 } elseif (isset($charset_of_file) && $charset_of_file != 'utf-8') {
 528     $dbi->query('SET NAMES \'' . $charset_of_file . '\'');
 529     // We can not show query in this case, it is in different charset
 530     $sql_query_disabled = true;
 531     $reset_charset = true;
 532 }
 533
 534 // Something to skip? (because timeout has passed)
 535 if (! $error && isset($_POST['skip'])) {
 536     $original_skip = $skip = intval($_POST['skip']);
 537     while ($skip > 0 && ! $finished) {
 538         $import->getNextChunk($skip < $read_limit ? $skip : $read_limit);
 539         // Disable read progressivity, otherwise we eat all memory!
 540         $read_multiply = 1;
 541         $skip -= $read_limit;
 542     }
 543     unset($skip);
 544 }
 545
 546 // This array contain the data like numberof valid sql queries in the statement
 547 // and complete valid sql statement (which affected for rows)
 548 $sql_data = [
 549     'valid_sql' => [],
 550     'valid_queries' => 0,
 551 ];
 552
 553 if (! $error) {
 554     /**
 555      * @var ImportPlugin $import_plugin
 556      */
 557     $import_plugin = Plugins::getPlugin(
 558         "import",
 559         $format,
 560         'libraries/classes/Plugins/Import/',
 561         $import_type
 562     );
 563     if ($import_plugin == null) {
 564         $message = PhpMyAdmin\Message::error(
 565             __('Could not load import plugins, please check your installation!')
 566         );
 567         $import->stop($message);
 568     } else {
 569         // Do the real import
 570         $default_fk_check = PhpMyAdmin\Util::handleDisableFKCheckInit();
 571         try {
 572             $import_plugin->doImport($sql_data);
 573             PhpMyAdmin\Util::handleDisableFKCheckCleanup($default_fk_check);
 574         } catch (Exception $e) {
 575             PhpMyAdmin\Util::handleDisableFKCheckCleanup($default_fk_check);
 576             throw $e;
 577         }
 578     }
 579 }
 580
 581 if (isset($import_handle)) {
 582     $import_handle->close();
 583 }
 584
 585 // Cleanup temporary file
 586 if ($file_to_unlink != '') {
 587     unlink($file_to_unlink);
 588 }
 589
 590 // Reset charset back, if we did some changes
 591 if ($reset_charset) {
 592     $dbi->query('SET CHARACTER SET ' . $GLOBALS['charset_connection']);
 593     $dbi->setCollation($collation_connection);
 594 }
 595
 596 // Show correct message
 597 if (! empty($id_bookmark) && $_POST['action_bookmark'] == 2) {
 598     $message = PhpMyAdmin\Message::success(__('The bookmark has been deleted.'));
 599     $display_query = $import_text;
 600     $error = false; // unset error marker, it was used just to skip processing
 601 } elseif (! empty($id_bookmark) && $_POST['action_bookmark'] == 1) {
 602     $message = PhpMyAdmin\Message::notice(__('Showing bookmark'));
 603 } elseif ($bookmark_created) {
 604     $special_message = '[br]' . sprintf(
 605         __('Bookmark %s has been created.'),
 606         htmlspecialchars($_POST['bkm_label'])
 607     );
 608 } elseif ($finished && ! $error) {
 609     // Do not display the query with message, we do it separately
 610     $display_query = ';';
 611     if ($import_type != 'query') {
 612         $message = PhpMyAdmin\Message::success(
 613             '<em>'
 614             . _ngettext(
 615                 'Import has been successfully finished, %d query executed.',
 616                 'Import has been successfully finished, %d queries executed.',
 617                 $executed_queries
 618             )
 619             . '</em>'
 620         );
 621         $message->addParam($executed_queries);
 622
 623         if (! empty($import_notice)) {
 624             $message->addHtml($import_notice);
 625         }
 626         if (! empty($local_import_file)) {
 627             $message->addText('(' . $local_import_file . ')');
 628         } else {
 629             $message->addText('(' . $_FILES['import_file']['name'] . ')');
 630         }
 631     }
 632 }
 633
 634 // Did we hit timeout? Tell it user.
 635 if ($timeout_passed) {
 636     $urlparams['timeout_passed'] = '1';
 637     $urlparams['offset'] = $GLOBALS['offset'];
 638     if (isset($local_import_file)) {
 639         $urlparams['local_import_file'] = $local_import_file;
 640     }
 641
 642     $importUrl = $err_url = $goto . Url::getCommon($urlparams);
 643
 644     $message = PhpMyAdmin\Message::error(
 645         __(
 646             'Script timeout passed, if you want to finish import,'
 647             . ' please %sresubmit the same file%s and import will resume.'
 648         )
 649     );
 650     $message->addParamHtml('<a href="' . $importUrl . '">');
 651     $message->addParamHtml('</a>');
 652
 653     if ($offset == 0 || (isset($original_skip) && $original_skip == $offset)) {
 654         $message->addText(
 655             __(
 656                 'However on last run no data has been parsed,'
 657                 . ' this usually means phpMyAdmin won\'t be able to'
 658                 . ' finish this import unless you increase php time limits.'
 659             )
 660         );
 661     }
 662 }
 663
 664 // if there is any message, copy it into $_SESSION as well,
 665 // so we can obtain it by AJAX call
 666 if (isset($message)) {
 667     $_SESSION['Import_message']['message'] = $message->getDisplay();
 668 }
 669 // Parse and analyze the query, for correct db and table name
 670 // in case of a query typed in the query window
 671 // (but if the query is too large, in case of an imported file, the parser
 672 //  can choke on it so avoid parsing)
 673 $sqlLength = mb_strlen($sql_query);
 674 if ($sqlLength <= $GLOBALS['cfg']['MaxCharactersInDisplayedSQL']) {
 675     list(
 676         $analyzed_sql_results,
 677         $db,
 678         $table_from_sql
 679     ) = ParseAnalyze::sqlQuery($sql_query, $db);
 680     // @todo: possibly refactor
 681     extract($analyzed_sql_results);
 682
 683     if ($table != $table_from_sql && ! empty($table_from_sql)) {
 684         $table = $table_from_sql;
 685     }
 686 }
 687
 688 // There was an error?
 689 if (isset($my_die)) {
 690     foreach ($my_die as $key => $die) {
 691         PhpMyAdmin\Util::mysqlDie(
 692             $die['error'],
 693             $die['sql'],
 694             false,
 695             $err_url,
 696             $error
 697         );
 698     }
 699 }
 700
 701 if ($go_sql) {
 702     if (! empty($sql_data) && ($sql_data['valid_queries'] > 1)) {
 703         $_SESSION['is_multi_query'] = true;
 704         $sql_queries = $sql_data['valid_sql'];
 705     } else {
 706         $sql_queries = [$sql_query];
 707     }
 708
 709     $html_output = '';
 710
 711     foreach ($sql_queries as $sql_query) {
 712         // parse sql query
 713         list(
 714             $analyzed_sql_results,
 715             $db,
 716             $table_from_sql
 717         ) = ParseAnalyze::sqlQuery($sql_query, $db);
 718         // @todo: possibly refactor
 719         extract($analyzed_sql_results);
 720
 721         // Check if User is allowed to issue a 'DROP DATABASE' Statement
 722         if ($sql->hasNoRightsToDropDatabase(
 723             $analyzed_sql_results,
 724             $cfg['AllowUserDropDatabase'],
 725             $dbi->isSuperuser()
 726         )) {
 727             PhpMyAdmin\Util::mysqlDie(
 728                 __('"DROP DATABASE" statements are disabled.'),
 729                 '',
 730                 false,
 731                 $_SESSION['Import_message']['go_back_url']
 732             );
 733             return;
 734         } // end if
 735
 736         if ($table != $table_from_sql && ! empty($table_from_sql)) {
 737             $table = $table_from_sql;
 738         }
 739
 740         $html_output .= $sql->executeQueryAndGetQueryResponse(
 741             $analyzed_sql_results, // analyzed_sql_results
 742             false, // is_gotofile
 743             $db, // db
 744             $table, // table
 745             null, // find_real_end
 746             null, // sql_query_for_bookmark - see below
 747             null, // extra_data
 748             null, // message_to_show
 749             null, // message
 750             null, // sql_data
 751             $goto, // goto
 752             $pmaThemeImage, // pmaThemeImage
 753             null, // disp_query
 754             null, // disp_message
 755             null, // query_type
 756             $sql_query, // sql_query
 757             null, // selectedTables
 758             null // complete_query
 759         );
 760     }
 761
 762     // sql_query_for_bookmark is not included in Sql::executeQueryAndGetQueryResponse
 763     // since only one bookmark has to be added for all the queries submitted through
 764     // the SQL tab
 765     if (! empty($_POST['bkm_label']) && ! empty($import_text)) {
 766         $cfgBookmark = Bookmark::getParams($GLOBALS['cfg']['Server']['user']);
 767         $sql->storeTheQueryAsBookmark(
 768             $db,
 769             $cfgBookmark['user'],
 770             $_POST['sql_query'],
 771             $_POST['bkm_label'],
 772             isset($_POST['bkm_replace'])
 773         );
 774     }
 775
 776     $response->addJSON('ajax_reload', $ajax_reload);
 777     $response->addHTML($html_output);
 778     exit;
 779 } elseif ($result) {
 780     // Save a Bookmark with more than one queries (if Bookmark label given).
 781     if (! empty($_POST['bkm_label']) && ! empty($import_text)) {
 782         $cfgBookmark = Bookmark::getParams($GLOBALS['cfg']['Server']['user']);
 783         $sql->storeTheQueryAsBookmark(
 784             $db,
 785             $cfgBookmark['user'],
 786             $_POST['sql_query'],
 787             $_POST['bkm_label'],
 788             isset($_POST['bkm_replace'])
 789         );
 790     }
 791
 792     $response->setRequestStatus(true);
 793     $response->addJSON('message', PhpMyAdmin\Message::success($msg));
 794     $response->addJSON(
 795         'sql_query',
 796         PhpMyAdmin\Util::getMessage($msg, $sql_query, 'success')
 797     );
 798 } elseif ($result === false) {
 799     $response->setRequestStatus(false);
 800     $response->addJSON('message', PhpMyAdmin\Message::error($msg));
 801 } else {
 802     $active_page = $goto;
 803     include ROOT_PATH . $goto;
 804 }
 805
 806 // If there is request for ROLLBACK in the end.
 807 if (isset($_POST['rollback_query'])) {
 808     $dbi->query('ROLLBACK');
 809 }