Gecko [ 35.178.45.201 ]

Name	Size	Permission
Ajax.php	2.8 KB	-rw-r--r--
AnalysedColumn.php	262 B	-rw-r--r--
ColumnType.php	184 B	-rw-r--r--
DecimalSize.php	760 B	-rw-r--r--
Import.php	41.5 KB	-rw-r--r--
ImportSettings.php	1.12 KB	-rw-r--r--
ImportTable.php	336 B	-rw-r--r--
SimulateDml.php	4.85 KB	-rw-r--r--

Code Editor : Import.php

<?php

declare(strict_types=1);

namespace PhpMyAdmin\Import;

use PhpMyAdmin\Config;
use PhpMyAdmin\Current;
use PhpMyAdmin\DatabaseInterface;
use PhpMyAdmin\Encoding;
use PhpMyAdmin\File;
use PhpMyAdmin\FileListing;
use PhpMyAdmin\Message;
use PhpMyAdmin\Plugins\ImportPlugin;
use PhpMyAdmin\ResponseRenderer;
use PhpMyAdmin\SqlParser\Parser;
use PhpMyAdmin\SqlParser\Statements\DeleteStatement;
use PhpMyAdmin\SqlParser\Statements\InsertStatement;
use PhpMyAdmin\SqlParser\Statements\ReplaceStatement;
use PhpMyAdmin\SqlParser\Statements\UpdateStatement;
use PhpMyAdmin\SqlParser\Utils\Query;
use PhpMyAdmin\Table\Table;
use PhpMyAdmin\Url;
use PhpMyAdmin\Util;

use function __;
use function abs;
use function array_key_last;
use function array_map;
use function count;
use function explode;
use function function_exists;
use function htmlspecialchars;
use function implode;
use function in_array;
use function is_numeric;
use function max;
use function mb_chr;
use function mb_ord;
use function mb_stripos;
use function mb_strlen;
use function mb_strtoupper;
use function mb_substr;
use function mb_substr_count;
use function preg_grep;
use function preg_match;
use function preg_quote;
use function preg_replace;
use function rtrim;
use function sprintf;
use function str_contains;
use function str_starts_with;
use function substr;
use function time;
use function trim;

/**
 * Library that provides common import functions that are used by import plugins
 */
class Import
{
    private string|null $importRunBuffer = null;

public function __construct()
    {
        Config::getInstance()->selectedServer['DisableIS'] = false;
    }

/**
     * Checks whether timeout is getting close
     */
    public function checkTimeout(): bool
    {
        if (ImportSettings::$maximumTime === 0) {
            return false;
        }

if (ImportSettings::$timeoutPassed) {
            return true;

/* 5 in next row might be too much */
        }

if (time() - ImportSettings::$timestamp > ImportSettings::$maximumTime - 5) {
            ImportSettings::$timeoutPassed = true;

return true;
        }

return false;
    }

/**
     * Runs query inside import buffer. This is needed to allow displaying
     * of last SELECT, SHOW or HANDLER results and similar nice stuff.
     *
     * @param string   $sql     query to run
     * @param string[] $sqlData SQL parse data storage
     */
    public function executeQuery(string $sql, array &$sqlData): void
    {
        $GLOBALS['error'] ??= null;
        $dbi = DatabaseInterface::getInstance();
        $GLOBALS['result'] = $dbi->tryQuery($sql);

// USE query changes the database, son need to track
        // while running multiple queries
        $isUseQuery = mb_stripos($sql, 'use ') !== false;

ImportSettings::$message = '# ';
        if ($GLOBALS['result'] === false) {
            ImportSettings::$failedQueries[] = ['sql' => $sql, 'error' => $dbi->getError()];

ImportSettings::$message .= __('Error');

if (! Config::getInstance()->settings['IgnoreMultiSubmitErrors']) {
                $GLOBALS['error'] = true;

return;
            }
        } else {
            $aNumRows = (int) $GLOBALS['result']->numRows();
            $aAffectedRows = (int) @$dbi->affectedRows();
            if ($aNumRows > 0) {
                ImportSettings::$message .= __('Rows') . ': ' . $aNumRows;
            } elseif ($aAffectedRows > 0) {
                $message = Message::getMessageForAffectedRows($aAffectedRows);
                ImportSettings::$message .= $message->getMessage();
            } else {
                ImportSettings::$message .= __('MySQL returned an empty result set (i.e. zero rows).');
            }

if ($aNumRows > 0 || $isUseQuery) {
                $sqlData[] = $sql;
            }
        }

if (! ImportSettings::$sqlQueryDisabled) {
            $GLOBALS['sql_query'] .= ImportSettings::$message . "\n";
        }

// If a 'USE <db>' SQL-clause was found and the query
 // succeeded, set our current $db to the new one
 if ($GLOBALS['result'] != false) {
 $dbNameInsideUse = $this->lookForUse($sql);
 if ($dbNameInsideUse !== '') {
 Current::$database = $dbNameInsideUse;
 $GLOBALS['reload'] = true;
 }
 }

$pattern = '@^[\s]*(DROP|CREATE)[\s]+(IF EXISTS[[:space:]]+)?(TABLE|DATABASE)[[:space:]]+(.+)@im';
        if ($GLOBALS['result'] == false || ! preg_match($pattern, $sql)) {
            return;
        }

$GLOBALS['reload'] = true;
    }

/**
     * Runs query inside import buffer. This is needed to allow displaying
     * of last SELECT, SHOW or HANDLER results and similar nice stuff.
     *
     * @param string   $sql     query to run
     * @param string[] $sqlData SQL parse data storage
     */
    public function runQuery(string $sql, array &$sqlData): void
    {
        $GLOBALS['complete_query'] ??= null;
        $GLOBALS['display_query'] ??= null;

ImportSettings::$readMultiply = 1;
        if ($this->importRunBuffer === null) {
            // Do we have something to push into buffer?
            $this->importRunBuffer = $sql !== '' ? $sql . ';' : null;

return;
        }

// Should we skip something?
        if (ImportSettings::$skipQueries > 0) {
            ImportSettings::$skipQueries--;
            // Do we have something to push into buffer?
            $this->importRunBuffer = $sql !== '' ? $sql . ';' : null;

return;
        }

ImportSettings::$maxSqlLength = max(
            ImportSettings::$maxSqlLength,
            mb_strlen($this->importRunBuffer),
        );
        if (! ImportSettings::$sqlQueryDisabled) {
            $GLOBALS['sql_query'] .= $this->importRunBuffer;
        }

ImportSettings::$executedQueries++;

if (ImportSettings::$runQuery && ImportSettings::$executedQueries < 50) {
 ImportSettings::$goSql = true;

if (! ImportSettings::$sqlQueryDisabled) {
                $GLOBALS['complete_query'] = $GLOBALS['sql_query'];
                $GLOBALS['display_query'] = $GLOBALS['sql_query'];
            } else {
                $GLOBALS['complete_query'] = '';
                $GLOBALS['display_query'] = '';
            }

$GLOBALS['sql_query'] = $this->importRunBuffer;
            $sqlData[] = $this->importRunBuffer;
        } elseif (ImportSettings::$runQuery) {
            /* Handle rollback from go_sql */
            if (ImportSettings::$goSql && $sqlData !== []) {
                $queries = $sqlData;
                $sqlData = [];
                ImportSettings::$goSql = false;

foreach ($queries as $query) {
                    $this->executeQuery($query, $sqlData);
                }
            }

$this->executeQuery($this->importRunBuffer, $sqlData);
        }

// check length of query unless we decided to pass it to /sql
        // (if $run_query is false, we are just displaying so show
        // the complete query in the textarea)
        if (! ImportSettings::$goSql && ImportSettings::$runQuery && ! empty($GLOBALS['sql_query'])) {
            if (
                mb_strlen($GLOBALS['sql_query']) > 50000
                || ImportSettings::$executedQueries > 50
                || ImportSettings::$maxSqlLength > 1000
            ) {
                $GLOBALS['sql_query'] = '';
                ImportSettings::$sqlQueryDisabled = true;
            }
        }

// Do we have something to push into buffer?
        $this->importRunBuffer = $sql !== '' ? $sql . ';' : null;

// In case of ROLLBACK, notify the user.
        if (! isset($_POST['rollback_query'])) {
            return;
        }

ImportSettings::$message .= __('[ROLLBACK occurred.]');
    }

/**
     * Looks for the presence of USE to possibly change current db
     */
    public function lookForUse(string $buffer): string
    {
        if (preg_match('@^[\s]*USE[[:space:]]+([\S]+)@i', $buffer, $match)) {
            $db = trim($match[1]);
            $db = trim($db, ';'); // for example, USE abc;

// $db must not contain the escape characters generated by backquote()
            // ( used in buildSql() as: backquote($db_name), and then called
            // in runQuery() which in turn calls lookForUse() )
            return Util::unQuote($db);
        }

return '';
    }

/**
 * Returns next part of imported file/buffer
 *
 * @param int $size size of buffer to read (this is maximal size function will return)
 *
 * @return string|bool part of file/buffer
 */
 public function getNextChunk(File|null $importHandle = null, int $size = 32768): string|bool
 {
 // Add some progression while reading large amount of data
 if (ImportSettings::$readMultiply <= 8) {
 $size *= ImportSettings::$readMultiply;
 } else {
 $size *= 8;
 }

ImportSettings::$readMultiply++;

// We can not read too much
        if ($size > ImportSettings::$readLimit) {
            $size = ImportSettings::$readLimit;
        }

if ($this->checkTimeout()) {
            return false;
        }

if (ImportSettings::$finished) {
            return true;
        }

if (ImportSettings::$importFile === 'none') {
 // Well this is not yet supported and tested,
 // but should return content of textarea
 if (mb_strlen($GLOBALS['import_text']) < $size) {
 ImportSettings::$finished = true;

return $GLOBALS['import_text'];
            }

$r = mb_substr($GLOBALS['import_text'], 0, $size);
            ImportSettings::$offset += $size;
            $GLOBALS['import_text'] = mb_substr($GLOBALS['import_text'], $size);

return $r;
        }

if ($importHandle === null) {
            return false;
        }

$result = $importHandle->read($size);
        ImportSettings::$finished = $importHandle->eof();
        ImportSettings::$offset += $size;

if (ImportSettings::$charsetConversion) {
            return Encoding::convertString(ImportSettings::$charsetOfFile, 'utf-8', $result);
        }

if (ImportSettings::$offset === $size) {
            return $this->skipByteOrderMarksFromContents($result);
        }

return $result;
    }

/**
 * Skip possible byte order marks (I do not think we need more
 * charsets, but feel free to add more, you can use wikipedia for
 * reference: <https://en.wikipedia.org/wiki/Byte_Order_Mark>)
 *
 * @todo BOM could be used for charset autodetection
 */
 public function skipByteOrderMarksFromContents(string $contents): string
 {
 // Do not use mb_ functions they are sensible to mb_internal_encoding()

// UTF-8
        if (str_starts_with($contents, "\xEF\xBB\xBF")) {
            return substr($contents, 3);
        }

// UTF-16 BE, LE
        if (str_starts_with($contents, "\xFE\xFF") || str_starts_with($contents, "\xFF\xFE")) {
            return substr($contents, 2);
        }

return $contents;
    }

/**
     * Returns the "Excel" column name (i.e. 1 = "A", 26 = "Z", 27 = "AA", etc.)
     *
     * This functions uses recursion to build the Excel column name.
     *
     * The column number (1-26) is converted to the responding
     * ASCII character (A-Z) and returned.
     *
     * If the column number is bigger than 26 (= num of letters in alphabet),
     * an extra character needs to be added. To find this extra character,
     * the number is divided by 26 and this value is passed to another instance
     * of the same function (hence recursion). In that new instance the number is
     * evaluated again, and if it is still bigger than 26, it is divided again
     * and passed to another instance of the same function. This continues until
     * the number is smaller than 26. Then the last called function returns
     * the corresponding ASCII character to the function that called it.
     * Each time a called function ends an extra character is added to the column name.
     * When the first function is reached, the last character is added and the complete
     * column name is returned.
     *
     * @param int $num the column number
     *
     * @return string The column's "Excel" name
     */
    public function getColumnAlphaName(int $num): string
    {
        $capitalA = 65; // ASCII value for capital "A"
        $colName = '';

/** @infection-ignore-all */
        if ($num > 26) {
            $div = (int) ($num / 26);
            $remain = $num % 26;

// subtract 1 of divided value in case the modulus is 0,
            // this is necessary because A-Z has no 'zero'
            if ($remain === 0) {
                $div--;
            }

// recursive function call
            $colName = $this->getColumnAlphaName($div);
            // use modulus as new column number
            $num = $remain;
        }

if ($num === 0) {
            // use 'Z' if column number is 0,
            // this is necessary because A-Z has no 'zero'
            $colName .= mb_chr($capitalA + 26 - 1);
        } else {
            // convert column number to ASCII character
            $colName .= mb_chr($capitalA + $num - 1);
        }

return $colName;
    }

/**
     * Returns the column number based on the Excel name.
     * So "A" = 1, "Z" = 26, "AA" = 27, etc.
     *
     * Basically this is a base26 (A-Z) to base10 (0-9) conversion.
     * It iterates through all characters in the column name and
     * calculates the corresponding value, based on character value
     * (A = 1, ..., Z = 26) and position in the string.
     *
     * @param string $name column name(i.e. "A", or "BC", etc.)
     *
     * @return int The column number
     */
    public function getColumnNumberFromName(string $name): int
    {
        if ($name === '') {
            return 0;
        }

$name = mb_strtoupper($name);
 $numChars = mb_strlen($name);
 $columnNumber = 0;
 for ($i = 0; $i < $numChars; ++$i) {
 // read string from back to front
 $charPos = $numChars - 1 - $i;

// convert capital character to ASCII value
            // and subtract 64 to get corresponding decimal value
            // ASCII value of "A" is 65, "B" is 66, etc.
            // Decimal equivalent of "A" is 1, "B" is 2, etc.
            $number = mb_ord($name[$charPos]) - 64;

// base26 to base10 conversion : multiply each number
            // with corresponding value of the position, in this case
            // $i=0 : 1; $i=1 : 26; $i=2 : 676; ...
            $columnNumber += $number * 26 ** $i;
        }

return (int) $columnNumber;
    }

/**
     * Obtains the size of the given cell
     *
     * @param DecimalSize|int $lastCumulativeSize Last cumulative column size
     * @param ColumnType|null $lastCumulativeType Last cumulative column type
     * @param ColumnType      $currentCellType    Type of the current cell
     * @param string          $cell               The current cell
     *
     * @return DecimalSize|int Size of the given cell in the type-appropriate format
     *
     * @todo    Handle the error cases more elegantly
     */
    private function detectSize(
        DecimalSize|int $lastCumulativeSize,
        ColumnType|null $lastCumulativeType,
        ColumnType $currentCellType,
        string $cell,
    ): DecimalSize|int {
        $currSize = mb_strlen($cell);

/**
         * If the cell is NULL, don't treat it as a varchar
         */
        if ($cell === 'NULL') {
            return $lastCumulativeSize;
        }

if ($currentCellType === ColumnType::Varchar) {
            if ($lastCumulativeType === ColumnType::Varchar) {
                if ($currSize >= $lastCumulativeSize) {
                    return $currSize;
                }