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