{

private float $queryTime = 0;

public static bool|null $showAsPhp = null;

public static Message|null $usingBookmarkMessage = null;

public function __construct(

private readonly DatabaseInterface $dbi,

private readonly Relation $relation,

private readonly RelationCleanup $relationCleanup,

private readonly Transformations $transformations,

private readonly Template $template,

private readonly BookmarkRepository $bookmarkRepository,

private readonly Config $config,

private readonly ResponseRenderer $responseRenderer,

) {

}

/**

private function handleSortOrder(

string $db,

string $table,

StatementInfo $statementInfo,

string &$fullSqlQuery,

): StatementInfo {

if ($statementInfo->statement === null) {

return $statementInfo;

}

$tableObject = new Table($table, $db, $this->dbi);

if (! $statementInfo->flags->order) {

// Retrieving the name of the column we should sort after.

$sortCol = $tableObject->getUiProp(UiProperty::SortedColumn);

if (empty($sortCol)) {

return $statementInfo;

}

// Remove the name of the table from the retrieved field name.

$sortCol = str_replace(

Util::backquote($table) . '.',

'',

$sortCol,

);

// Create the new query.

$fullSqlQuery = Query::replaceClause(

$statementInfo->statement,

$statementInfo->parser->list,

'ORDER BY ' . $sortCol,

);

// TODO: Avoid reparsing the query.

$statementInfo = Query::getAll($fullSqlQuery);

} else {

// Store the remembered table into session.

$tableObject->setUiProp(

UiProperty::SortedColumn,

Query::getClause(

$statementInfo->statement,

$statementInfo->parser->list,

'ORDER BY',

),

);

}

return $statementInfo;

}

/**

private function getSqlWithLimitClause(StatementInfo $statementInfo): string

{

if ($statementInfo->statement === null) {

return '';

}

return Query::replaceClause(

$statementInfo->statement,

$statementInfo->parser->list,

'LIMIT ' . $_SESSION['tmpval']['pos'] . ', '

. $_SESSION['tmpval']['max_rows'],

);

}

/**

private function resultSetHasJustOneTable(array $fieldsMeta): bool

{

$justOneTable = true;

$prevTable = '';

foreach ($fieldsMeta as $oneFieldMeta) {

if ($oneFieldMeta->table !== '' && $prevTable !== '' && $oneFieldMeta->table !== $prevTable) {

$justOneTable = false;

}

if ($oneFieldMeta->table === '') {

continue;

}

$prevTable = $oneFieldMeta->table;

}

return $justOneTable && $prevTable !== '';

}

/**

private function resultSetContainsUniqueKey(string $db, string $table, array $fieldsMeta): bool

{

if ($table === '') {

return false;

}

$columns = $this->dbi->getColumns($db, $table);

$resultSetColumnNames = [];

foreach ($fieldsMeta as $oneMeta) {

$resultSetColumnNames[] = $oneMeta->name;

}

foreach (Index::getFromTable($this->dbi, $table, $db) as $index) {

if (! $index->isUnique()) {

continue;

}

$indexColumns = $index->getColumns();

$numberFound = 0;

foreach (array_keys($indexColumns) as $indexColumnName) {

if (

! in_array($indexColumnName, $resultSetColumnNames)

&& array_key_exists($indexColumnName, $columns)

&& ! str_contains($columns[$indexColumnName]->extra, 'INVISIBLE')

) {

continue;

}

$numberFound++;

}

if ($numberFound === count($indexColumns)) {

return true;

}

}

return false;

}

/**

public function getHtmlForRelationalColumnDropdown(

string $db,

string $table,

string $column,

string $currentValue,

string $currentValueParam,

): string {

$foreignData = $this->relation->getForeignData(

$this->relation->getForeigners($db, $table, $column),

$column,

false,

'',

'',

);

if ($foreignData->dispRow === null) {

//Handle the case when number of values

//is more than $cfg['ForeignKeyMaxLimit']

$urlParams = ['db' => $db, 'table' => $table, 'field' => $column];

return $this->template->render('sql/relational_column_dropdown', [

'current_value' => $currentValueParam,

'params' => $urlParams,

]);

}

$dropdown = $this->relation->foreignDropdown(

$foreignData->dispRow,

$foreignData->foreignField ?? '',

$foreignData->foreignDisplay,

$currentValue,

$this->config->settings['ForeignKeyMaxLimit'],

);

return '<select>' . $dropdown . '</select>';

}

/**

private function getDetailedProfilingStats(array $profilingResults): array

{

$totalTime = (float) array_sum(array_column($profilingResults, 'Duration'));

if ($totalTime === 0.0) {

return [];

}

$states = [];

$profile = [];

foreach ($profilingResults as $result) {

$status = ucwords($result['Status']);

$profile[] = [

'status' => $status,

'duration' => Util::formatNumber($result['Duration'], 3, 1),

'duration_raw' => $result['Duration'],

];

if (! isset($states[$status])) {

$states[$status] = ['total_time' => (float) $result['Duration'], 'calls' => 1];

} else {

$states[$status]['calls']++;

$states[$status]['total_time'] += $result['Duration'];

}

}

arsort($states);

$chart = ['labels' => array_keys($states), 'data' => array_column($states, 'total_time')];

return ['total_time' => $totalTime, 'states' => $states, 'chart' => $chart, 'profile' => $profile];

}

/**

public function getFullValuesForSetColumn(

string $db,

string $table,

string $column,

string $whereClause,

): string {

$row = $this->dbi->fetchSingleRow(sprintf(

'SELECT `%s` FROM `%s`.`%s` WHERE %s',

$column,

$db,

$table,

$whereClause,

));

if ($row === []) {

return '';

}

return $row[$column];

}

/**

public function getValuesForColumn(string $db, string $table, string $columnName): array|null

{

$column = $this->dbi->getColumn($db, $table, $columnName);

if ($column === null) {

return null;

}

return Util::parseEnumSetValues($column->type, false);

}

/**

private function isRememberSortingOrder(StatementInfo $statementInfo): bool

{

return $this->config->settings['RememberSorting']

&& ! ($statementInfo->flags->isCount

|| $statementInfo->flags->isExport

|| $statementInfo->flags->isFunc

|| $statementInfo->flags->isAnalyse)

&& $statementInfo->flags->selectFrom

&& ($statementInfo->selectExpressions === []

|| (count($statementInfo->selectExpressions) === 1

&& $statementInfo->selectExpressions[0] === '*'))

&& count($statementInfo->selectTables) === 1;

}

/**

private function isAppendLimitClause(StatementInfo $statementInfo): bool

{

// Assigning LIMIT clause to an syntactically-wrong query

// is not needed. Also we would want to show the true query

// and the true error message to the query executor

return $statementInfo->parser->errors === []

&& $_SESSION['tmpval']['max_rows'] !== 'all'

&& ! $statementInfo->flags->isExport && ! $statementInfo->flags->isAnalyse

&& ($statementInfo->flags->selectFrom || $statementInfo->flags->isSubQuery)

&& ! $statementInfo->flags->limit;

}

/**

public static function isJustBrowsing(StatementInfo $statementInfo, bool $findRealEnd = false): bool

{

return ! $statementInfo->flags->isGroup

&& ! $statementInfo->flags->isFunc

&& ! $statementInfo->flags->union

&& ! $statementInfo->flags->distinct

&& $statementInfo->flags->selectFrom

&& (count($statementInfo->selectTables) === 1)

&& (empty($statementInfo->statement->where)

|| (count($statementInfo->statement->where) === 1

&& $statementInfo->statement->where[0]->expr === '1'))

&& ! $statementInfo->flags->group

&& ! $findRealEnd

&& ! $statementInfo->flags->isSubQuery

&& ! $statementInfo->flags->join

&& ! $statementInfo->flags->having;

}

/**

private function isDeleteTransformationInfo(StatementInfo $statementInfo): bool

{

return $statementInfo->flags->queryType === StatementType::Alter

|| $statementInfo->flags->queryType === StatementType::Drop;

}

public function hasNoRightsToDropDatabase(

StatementInfo $statementInfo,

): bool {

return ! $this->config->settings['AllowUserDropDatabase']

&& $statementInfo->flags->dropDatabase

&& ! $this->dbi->isSuperUser();

}

/**

public function getDefaultSqlQueryForBrowse(string $db, string $table): string

{

$bookmark = $this->bookmarkRepository->getByLabel(

$this->config->selectedServer['user'],

DatabaseName::from($db),

$table,

);

if ($bookmark !== null && $bookmark->getQuery() !== '') {

self::$usingBookmarkMessage = Message::notice(__('Using bookmark "%s" as default browse query.'));

self::$usingBookmarkMessage->addParam($table);

self::$usingBookmarkMessage->addHtml(MySQLDocumentation::showDocumentation('faq', 'faq6-22'));

return $bookmark->getQuery();

}

$defaultOrderByClause = '';

if (

isset($this->config->settings['TablePrimaryKeyOrder'])

&& ($this->config->settings['TablePrimaryKeyOrder'] !== 'NONE')

) {

$primaryKey = null;

$primary = Index::getPrimary($this->dbi, $table, $db);

if ($primary !== null) {

$primarycols = $primary->getColumns();

foreach ($primarycols as $col) {

$primaryKey = $col->getName();

break;

}

if ($primaryKey !== null) {

$defaultOrderByClause = ' ORDER BY '

. Util::backquote($table) . '.'

. Util::backquote($primaryKey) . ' '

. $this->config->settings['TablePrimaryKeyOrder'];

}

}

}

return 'SELECT * FROM ' . Util::backquote($table) . $defaultOrderByClause;

}

/**

private function handleQueryExecuteError(bool $isGotoFile, string $error, string $fullSqlQuery): never

{

if ($isGotoFile) {

$message = Message::rawError($error);

$this->responseRenderer->setRequestStatus(false);

$this->responseRenderer->addJSON('message', $message);

} else {

$errorMessage = Generator::mysqlDie($error, $fullSqlQuery, false);

if ($this->responseRenderer->isAjax()) {

$this->responseRenderer->setRequestStatus(false);

$this->responseRenderer->addJSON('message', $errorMessage);

$this->responseRenderer->callExit();

}

$this->responseRenderer->addHTML($errorMessage);

}

$this->responseRenderer->callExit();

}

/**

public function storeTheQueryAsBookmark(

string $db,

string $bookmarkUser,

string $sqlQueryForBookmark,

string $bookmarkLabel,

bool $bookmarkReplace,

bool $hasBookmarkAllUsers,

): void {

if ($bookmarkReplace) {

$bookmarks = $this->bookmarkRepository->getList($this->config->selectedServer['user'], $db);

foreach ($bookmarks as $bookmark) {

if ($bookmark->getLabel() !== $bookmarkLabel) {

continue;

}

$bookmark->delete();

}

}

$bookmark = $this->bookmarkRepository->createBookmark(

$sqlQueryForBookmark,

$bookmarkLabel,

$bookmarkUser,

$db,

$hasBookmarkAllUsers,

);

if ($bookmark === false) {

return;

}

$bookmark->save();

}

/**

private function getNumberOfRowsAffectedOrChanged(bool $isAffected, ResultInterface|false $result): int|string

{

if ($isAffected) {

return $this->dbi->affectedRows();

}

if ($result) {

return $result->numRows();

}

return 0;

}

/**

private function hasCurrentDbChanged(string $db): bool

{

if ($db === '') {

return false;

}

/** Is false, except when a USE statement was sent. */

$currentDb = $this->dbi->fetchValue('SELECT DATABASE()');

return is_string($currentDb) && $db !== $currentDb;

}

/**

private function cleanupRelations(string $db, string $table, string $column, bool $purge): void

{

if (! $purge || $db === '') {

return;

}

if ($table !== '') {

if ($column !== '') {

$this->relationCleanup->column($db, $table, $column);

} else {

$this->relationCleanup->table($db, $table);

}

} else {

$this->relationCleanup->database($db);

}

}

/**

private function countQueryResults(

int|string $numRows,

bool $justBrowsing,

string $db,

string $table,

StatementInfo $statementInfo,

): int|string {

/* Shortcut for not analyzed/empty query */

if ($statementInfo->statement === null) {

return 0;

}

if (! $this->isAppendLimitClause($statementInfo)) {

// if we did not append a limit, set this to get a correct

// "Showing rows..." message

// $_SESSION['tmpval']['max_rows'] = 'all';

$unlimNumRows = $numRows;

} elseif ($_SESSION['tmpval']['max_rows'] > $numRows) {

// When user has not defined a limit in query and total rows in

// result are less than max_rows to display, there is no need

// to count total rows for that query again

$unlimNumRows = $_SESSION['tmpval']['pos'] + $numRows;

} elseif ($statementInfo->flags->queryType === StatementType::Select || $statementInfo->flags->isSubQuery) {

// c o u n t q u e r y

// If we are "just browsing", there is only one table (and no join),

// and no WHERE clause (or just 'WHERE 1 '),

// we do a quick count (which uses MaxExactCount) because

// SQL_CALC_FOUND_ROWS is not quick on large InnoDB tables

if ($justBrowsing) {

// Get row count (is approximate for InnoDB)

$unlimNumRows = $this->dbi->getTable($db, $table)->countRecords();

/**

if ($unlimNumRows < $this->config->settings['MaxExactCount']) {

// Get the exact count if approximate count

// is less than MaxExactCount

/**

$unlimNumRows = $this->dbi->getTable($db, $table)->countRecords(true);

}

} else {

$statement = $statementInfo->statement;

assert($statement instanceof SelectStatement);

assert($statement->options !== null);

/** @var int|null $noCacheIndex */

$noCacheIndex = array_find_key(

$statement->options->options,

static fn (mixed $value): bool => is_string($value) && strtoupper($value) === 'SQL_NO_CACHE',

);

$changeExpression = ! $statementInfo->flags->isGroup

&& ! $statementInfo->flags->distinct

&& ! $statementInfo->flags->union

&& count($statement->expr) === 1;

if (

$statementInfo->flags->order

|| $statementInfo->flags->limit

|| $changeExpression

|| $noCacheIndex !== null

) {

$statement = clone $statement;

// Remove SQL_NO_CACHE from subquery because it is not valid sql

if ($noCacheIndex !== null) {

assert($statement->options !== null);

$statement->options = clone $statement->options;

unset($statement->options->options[$noCacheIndex]);

}

}

// Remove ORDER BY to decrease unnecessary sorting time

$statement->order = null;

// Removes LIMIT clause that might have been added

$statement->limit = null;

if ($changeExpression) {

$statement->expr[0] = new Expression();

$statement->expr[0]->expr = '1';

}

$countQuery = 'SELECT COUNT(*) FROM (' . $statement->build() . ' ) as cnt';

$unlimNumRows = (int) $this->dbi->fetchValue($countQuery);

}

} else {// not $is_select

$unlimNumRows = 0;

}

return $unlimNumRows;

}

/**

private function executeTheQuery(

ServerRequest $request,

StatementInfo $statementInfo,

string $fullSqlQuery,

bool $isGotoFile,

string $db,

string $table,

string $sqlQueryForBookmark,

): array {

$this->responseRenderer->getHeader()->getMenu()->setTable($table);

Profiling::enable($this->dbi);

if (! defined('TESTSUITE')) {

// close session in case the query takes too long

session_write_close();

}

$result = $this->dbi->tryQuery($fullSqlQuery);

$this->queryTime = $this->dbi->lastQueryExecutionTime;

if (! defined('TESTSUITE')) {

// reopen session but prevent PHP from sending the session cookie again

session_start(['use_cookies' => false]);

}

$errorMessage = '';

// Displays an error message if required and stop parsing the script

$error = $this->dbi->getError();

if ($error && $this->config->settings['IgnoreMultiSubmitErrors']) {

$errorMessage = $error;

} elseif ($error !== '') {

$this->handleQueryExecuteError($isGotoFile, $error, $fullSqlQuery);

}

// If there are no errors and bookmarklabel was given,

// store the query as a bookmark

$bookmarkLabel = $request->getParsedBodyParamAsString('bkm_label', '');

if ($bookmarkLabel !== '' && $sqlQueryForBookmark) {

$this->storeTheQueryAsBookmark(

$db,

$this->config->selectedServer['user'],

$sqlQueryForBookmark,

$bookmarkLabel,

$request->hasBodyParam('bkm_replace'),

$request->hasBodyParam('bkm_all_users'),

);

}

// Gets the number of rows affected/returned

// (This must be done immediately after the query because

// mysql_affected_rows() reports about the last query done)

$numRows = $this->getNumberOfRowsAffectedOrChanged($statementInfo->flags->isAffected, $result);

$profilingResults = Profiling::getInformation($this->dbi);

$justBrowsing = self::isJustBrowsing($statementInfo);

$unlimNumRows = $this->countQueryResults($numRows, $justBrowsing, $db, $table, $statementInfo);

$this->cleanupRelations(

$db,

$table,

$request->getParsedBodyParamAsString('dropped_column', ''),

$request->hasBodyParam('purge'),

);

return [$result, $numRows, $unlimNumRows, $profilingResults, $errorMessage];

}

/**

private function deleteTransformationInfo(string $db, string $table, StatementInfo $statementInfo): void

{

if ($statementInfo->statement === null) {

return;

}

$statement = $statementInfo->statement;

if ($statement instanceof AlterStatement) {

if (

! empty($statement->altered[0])

&& $statement->altered[0]->options->has('DROP')

&& ! empty($statement->altered[0]->field->column)

) {

$this->transformations->clear($db, $table, $statement->altered[0]->field->column);

}

} elseif ($statement instanceof DropStatement) {

$this->transformations->clear($db, $table);

}

}

/**

private function getMessageForNoRowsReturned(

string $messageToShow,

StatementInfo $statementInfo,

int|string $numRows,

bool $hasRollbackQuery,

): Message {

if ($statementInfo->flags->queryType === StatementType::Delete) {

$message = Message::getMessageForDeletedRows($numRows);

} elseif ($statementInfo->flags->isInsert) {

if ($statementInfo->flags->queryType === StatementType::Replace) {

// For REPLACE we get DELETED + INSERTED row count,

// so we have to call it affected

$message = Message::getMessageForAffectedRows($numRows);

} else {

$message = Message::getMessageForInsertedRows($numRows);

}

$insertId = $this->dbi->insertId();

if ($insertId !== 0) {

// insert_id is id of FIRST record inserted in one insert,

// so if we inserted multiple rows, we had to increment this

$message->addText('[br]');

// need to use a temporary because the Message class

// currently supports adding parameters only to the first

// message

$inserted = Message::notice(__('Inserted row id: %1$d'));

$inserted->addParam($insertId + $numRows - 1);

$message->addMessage($inserted);

}

} elseif ($statementInfo->flags->isAffected) {

$message = Message::getMessageForAffectedRows($numRows);

// Ok, here is an explanation for the !$is_select.

// The form generated by PhpMyAdmin\SqlQueryForm

// and /database/sql has many submit buttons

// on the same form, and some confusion arises from the

// fact that $message_to_show is sent for every case.

// The $message_to_show containing a success message and sent with

// the form should not have priority over errors

} elseif ($messageToShow !== '' && $statementInfo->flags->queryType !== StatementType::Select) {

$message = Message::rawSuccess(htmlspecialchars($messageToShow));

} elseif (self::$showAsPhp === true) {

$message = Message::success(__('Showing as PHP code'));

} elseif (self::$showAsPhp === false) {

/* User disable showing as PHP, query is only displayed */

$message = Message::notice(__('Showing SQL query'));

} else {

$message = Message::success(

__('MySQL returned an empty result set (i.e. zero rows).'),

);

}

if ($this->queryTime > 0) {

$queryTime = Message::notice(

'(' . __('Query took %01.4f seconds.') . ')',

);

$queryTime->addParam($this->queryTime);

$message->addMessage($queryTime);

}

// In case of ROLLBACK, notify the user.

if ($hasRollbackQuery) {

$message->addText(__('[ROLLBACK occurred.]'));

}

return $message;

}

/**

private function getQueryResponseForNoResultsReturned(

ServerRequest $request,

StatementInfo $statementInfo,

string $db,

string|null $table,

string $messageToShow,

int|string $numRows,

DisplayResults $displayResultsObject,

string $errorMessage,

array $profilingResults,

ResultInterface|false $result,

string $sqlQuery,

string $completeQuery,

): string {

if ($this->isDeleteTransformationInfo($statementInfo)) {

$this->deleteTransformationInfo($db, $table ?? '', $statementInfo);

}

if ($errorMessage !== '') {

$message = Message::rawError($errorMessage);

} else {

$message = $this->getMessageForNoRowsReturned(

$messageToShow,

$statementInfo,

$numRows,

$request->hasBodyParam('rollback_query'),

);

}

$queryMessage = Generator::getMessage($message, $sqlQuery, MessageType::Success);

if (self::$showAsPhp !== null) {

return $queryMessage;

}

$extraData = [];

if (ResponseRenderer::$reload) {

$extraData['reload'] = 1;

$extraData['db'] = Current::$database;

}

// For ajax requests add message and sql_query as JSON

if (! $request->has('ajax_page_request')) {

$extraData['message'] = $message;

if ($this->config->settings['ShowSQL']) {

$extraData['sql_query'] = $queryMessage;

}

}

if (

$request->hasBodyParam('dropped_column')

&& $db !== '' && $table !== null && $table !== ''

) {

// to refresh the list of indexes (Ajax mode)

$extraData['indexes_list'] = $this->getIndexList($table, $db);

}

$this->responseRenderer->addJSON($extraData);

$header = $this->responseRenderer->getHeader();

$scripts = $header->getScripts();

$scripts->addFile('sql.js');

// We can only skip result fetching if the result contains no columns.

if (($result instanceof ResultInterface && $result->numFields() === 0) || $result === false) {

return $queryMessage;

}