You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1606 lines
57 KiB
1606 lines
57 KiB
<?php |
|
|
|
declare(strict_types=1); |
|
|
|
namespace PhpMyAdmin\Database; |
|
|
|
use PhpMyAdmin\Charsets; |
|
use PhpMyAdmin\DatabaseInterface; |
|
use PhpMyAdmin\Html\Generator; |
|
use PhpMyAdmin\Message; |
|
use PhpMyAdmin\ResponseRenderer; |
|
use PhpMyAdmin\SqlParser\Parser; |
|
use PhpMyAdmin\SqlParser\Statements\CreateStatement; |
|
use PhpMyAdmin\SqlParser\TokensList; |
|
use PhpMyAdmin\SqlParser\Utils\Routine; |
|
use PhpMyAdmin\Template; |
|
use PhpMyAdmin\Util; |
|
|
|
use function __; |
|
use function _ngettext; |
|
use function array_merge; |
|
use function count; |
|
use function explode; |
|
use function htmlentities; |
|
use function htmlspecialchars; |
|
use function implode; |
|
use function in_array; |
|
use function is_array; |
|
use function is_string; |
|
use function max; |
|
use function mb_strtolower; |
|
use function mb_strtoupper; |
|
use function preg_match; |
|
use function sprintf; |
|
use function str_contains; |
|
use function stripos; |
|
use function substr; |
|
use function trim; |
|
|
|
use const ENT_QUOTES; |
|
|
|
/** |
|
* Functions for routine management. |
|
*/ |
|
class Routines |
|
{ |
|
/** @var array<int, string> */ |
|
private $directions = ['IN', 'OUT', 'INOUT']; |
|
|
|
/** @var array<int, string> */ |
|
private $sqlDataAccess = ['CONTAINS SQL', 'NO SQL', 'READS SQL DATA', 'MODIFIES SQL DATA']; |
|
|
|
/** @var array<int, string> */ |
|
private $numericOptions = ['UNSIGNED', 'ZEROFILL', 'UNSIGNED ZEROFILL']; |
|
|
|
/** @var DatabaseInterface */ |
|
private $dbi; |
|
|
|
/** @var Template */ |
|
private $template; |
|
|
|
/** @var ResponseRenderer */ |
|
private $response; |
|
|
|
/** |
|
* @param DatabaseInterface $dbi DatabaseInterface instance. |
|
* @param Template $template Template instance. |
|
* @param ResponseRenderer $response Response instance. |
|
*/ |
|
public function __construct(DatabaseInterface $dbi, Template $template, $response) |
|
{ |
|
$this->dbi = $dbi; |
|
$this->template = $template; |
|
$this->response = $response; |
|
} |
|
|
|
/** |
|
* Handles editor requests for adding or editing an item |
|
*/ |
|
public function handleEditor(): void |
|
{ |
|
global $db, $errors; |
|
|
|
$errors = $this->handleRequestCreateOrEdit($errors, $db); |
|
|
|
/** |
|
* Display a form used to add/edit a routine, if necessary |
|
*/ |
|
// FIXME: this must be simpler than that |
|
if ( |
|
! count($errors) |
|
&& ( ! empty($_POST['editor_process_add']) |
|
|| ! empty($_POST['editor_process_edit']) |
|
|| (empty($_REQUEST['add_item']) && empty($_REQUEST['edit_item']) |
|
&& empty($_POST['routine_addparameter']) |
|
&& empty($_POST['routine_removeparameter']) |
|
&& empty($_POST['routine_changetype']))) |
|
) { |
|
return; |
|
} |
|
|
|
// Handle requests to add/remove parameters and changing routine type |
|
// This is necessary when JS is disabled |
|
$operation = ''; |
|
if (! empty($_POST['routine_addparameter'])) { |
|
$operation = 'add'; |
|
} elseif (! empty($_POST['routine_removeparameter'])) { |
|
$operation = 'remove'; |
|
} elseif (! empty($_POST['routine_changetype'])) { |
|
$operation = 'change'; |
|
} |
|
|
|
// Get the data for the form (if any) |
|
$routine = null; |
|
$mode = null; |
|
$title = null; |
|
if (! empty($_REQUEST['add_item'])) { |
|
$title = __('Add routine'); |
|
$routine = $this->getDataFromRequest(); |
|
$mode = 'add'; |
|
} elseif (! empty($_REQUEST['edit_item'])) { |
|
$title = __('Edit routine'); |
|
if (! $operation && ! empty($_GET['item_name']) && empty($_POST['editor_process_edit'])) { |
|
$routine = $this->getDataFromName($_GET['item_name'], $_GET['item_type']); |
|
if ($routine !== null) { |
|
$routine['item_original_name'] = $routine['item_name']; |
|
$routine['item_original_type'] = $routine['item_type']; |
|
} |
|
} else { |
|
$routine = $this->getDataFromRequest(); |
|
} |
|
|
|
$mode = 'edit'; |
|
} |
|
|
|
if ($routine !== null) { |
|
// Show form |
|
$editor = $this->getEditorForm($mode, $operation, $routine); |
|
if ($this->response->isAjax()) { |
|
$this->response->addJSON('message', $editor); |
|
$this->response->addJSON('title', $title); |
|
$this->response->addJSON('paramTemplate', $this->getParameterRow()); |
|
$this->response->addJSON('type', $routine['item_type']); |
|
} else { |
|
echo "\n\n<h2>" . $title . "</h2>\n\n" . $editor; |
|
} |
|
|
|
exit; |
|
} |
|
|
|
$message = __('Error in processing request:') . ' '; |
|
$message .= sprintf( |
|
__( |
|
'No routine with name %1$s found in database %2$s. ' |
|
. 'You might be lacking the necessary privileges to edit this routine.' |
|
), |
|
htmlspecialchars( |
|
Util::backquote($_REQUEST['item_name']) |
|
), |
|
htmlspecialchars(Util::backquote($db)) |
|
); |
|
|
|
$message = Message::error($message); |
|
if ($this->response->isAjax()) { |
|
$this->response->setRequestStatus(false); |
|
$this->response->addJSON('message', $message); |
|
exit; |
|
} |
|
|
|
echo $message->getDisplay(); |
|
} |
|
|
|
/** |
|
* Handle request to create or edit a routine |
|
* |
|
* @param array $errors Errors |
|
* @param string $db DB name |
|
* |
|
* @return array |
|
*/ |
|
public function handleRequestCreateOrEdit(array $errors, $db) |
|
{ |
|
global $message; |
|
|
|
if (empty($_POST['editor_process_add']) && empty($_POST['editor_process_edit'])) { |
|
return $errors; |
|
} |
|
|
|
$sql_query = ''; |
|
$routine_query = $this->getQueryFromRequest(); |
|
|
|
// set by getQueryFromRequest() |
|
if (! count($errors)) { |
|
// Execute the created query |
|
if (! empty($_POST['editor_process_edit'])) { |
|
$isProcOrFunc = in_array( |
|
$_POST['item_original_type'], |
|
[ |
|
'PROCEDURE', |
|
'FUNCTION', |
|
] |
|
); |
|
|
|
if (! $isProcOrFunc) { |
|
$errors[] = sprintf( |
|
__('Invalid routine type: "%s"'), |
|
htmlspecialchars($_POST['item_original_type']) |
|
); |
|
} else { |
|
// Backup the old routine, in case something goes wrong |
|
$create_routine = $this->dbi->getDefinition( |
|
$db, |
|
$_POST['item_original_type'], |
|
$_POST['item_original_name'] |
|
); |
|
|
|
$privilegesBackup = $this->backupPrivileges(); |
|
|
|
$drop_routine = 'DROP ' . $_POST['item_original_type'] . ' ' |
|
. Util::backquote($_POST['item_original_name']) |
|
. ";\n"; |
|
$result = $this->dbi->tryQuery($drop_routine); |
|
if (! $result) { |
|
$errors[] = sprintf( |
|
__('The following query has failed: "%s"'), |
|
htmlspecialchars($drop_routine) |
|
) |
|
. '<br>' |
|
. __('MySQL said: ') . $this->dbi->getError(); |
|
} else { |
|
[$newErrors, $message] = $this->create($routine_query, $create_routine, $privilegesBackup); |
|
if (empty($newErrors)) { |
|
$sql_query = $drop_routine . $routine_query; |
|
} else { |
|
$errors = array_merge($errors, $newErrors); |
|
} |
|
|
|
unset($newErrors); |
|
} |
|
} |
|
} else { |
|
// 'Add a new routine' mode |
|
$result = $this->dbi->tryQuery($routine_query); |
|
if (! $result) { |
|
$errors[] = sprintf( |
|
__('The following query has failed: "%s"'), |
|
htmlspecialchars($routine_query) |
|
) |
|
. '<br><br>' |
|
. __('MySQL said: ') . $this->dbi->getError(); |
|
} else { |
|
$message = Message::success( |
|
__('Routine %1$s has been created.') |
|
); |
|
$message->addParam( |
|
Util::backquote($_POST['item_name']) |
|
); |
|
$sql_query = $routine_query; |
|
} |
|
} |
|
} |
|
|
|
if (count($errors)) { |
|
$message = Message::error( |
|
__( |
|
'One or more errors have occurred while processing your request:' |
|
) |
|
); |
|
$message->addHtml('<ul>'); |
|
foreach ($errors as $string) { |
|
$message->addHtml('<li>' . $string . '</li>'); |
|
} |
|
|
|
$message->addHtml('</ul>'); |
|
} |
|
|
|
$output = Generator::getMessage($message, $sql_query); |
|
|
|
if (! $this->response->isAjax()) { |
|
return $errors; |
|
} |
|
|
|
if (! $message->isSuccess()) { |
|
$this->response->setRequestStatus(false); |
|
$this->response->addJSON('message', $output); |
|
exit; |
|
} |
|
|
|
$routines = $this->dbi->getRoutines($db, $_POST['item_type'], $_POST['item_name']); |
|
$routine = $routines[0]; |
|
$this->response->addJSON( |
|
'name', |
|
htmlspecialchars( |
|
mb_strtoupper($_POST['item_name']) |
|
) |
|
); |
|
$this->response->addJSON('new_row', $this->getRow($routine)); |
|
$this->response->addJSON('insert', ! empty($routine)); |
|
$this->response->addJSON('message', $output); |
|
$this->response->addJSON('tableType', 'routines'); |
|
exit; |
|
} |
|
|
|
/** |
|
* Backup the privileges |
|
* |
|
* @return array |
|
*/ |
|
public function backupPrivileges() |
|
{ |
|
if (! $GLOBALS['proc_priv'] || ! $GLOBALS['is_reload_priv']) { |
|
return []; |
|
} |
|
|
|
// Backup the Old Privileges before dropping |
|
// if $_POST['item_adjust_privileges'] set |
|
if (! isset($_POST['item_adjust_privileges']) || empty($_POST['item_adjust_privileges'])) { |
|
return []; |
|
} |
|
|
|
$privilegesBackupQuery = 'SELECT * FROM ' . Util::backquote('mysql') |
|
. '.' . Util::backquote('procs_priv') |
|
. ' where Routine_name = "' . $_POST['item_original_name'] |
|
. '" AND Routine_type = "' . $_POST['item_original_type'] |
|
. '";'; |
|
|
|
return $this->dbi->fetchResult($privilegesBackupQuery, 0); |
|
} |
|
|
|
/** |
|
* Create the routine |
|
* |
|
* @param string $routine_query Query to create routine |
|
* @param string $create_routine Query to restore routine |
|
* @param array $privilegesBackup Privileges backup |
|
* |
|
* @return array |
|
*/ |
|
public function create( |
|
$routine_query, |
|
$create_routine, |
|
array $privilegesBackup |
|
) { |
|
$result = $this->dbi->tryQuery($routine_query); |
|
if (! $result) { |
|
$errors = []; |
|
$errors[] = sprintf( |
|
__('The following query has failed: "%s"'), |
|
htmlspecialchars($routine_query) |
|
) |
|
. '<br>' |
|
. __('MySQL said: ') . $this->dbi->getError(); |
|
// We dropped the old routine, |
|
// but were unable to create the new one |
|
// Try to restore the backup query |
|
$result = $this->dbi->tryQuery($create_routine); |
|
if (! $result) { |
|
$errors = $this->checkResult($create_routine, $errors); |
|
} |
|
|
|
return [ |
|
$errors, |
|
null, |
|
]; |
|
} |
|
|
|
// Default value |
|
$resultAdjust = false; |
|
|
|
if ($GLOBALS['proc_priv'] && $GLOBALS['is_reload_priv']) { |
|
// Insert all the previous privileges |
|
// but with the new name and the new type |
|
foreach ($privilegesBackup as $priv) { |
|
$adjustProcPrivilege = 'INSERT INTO ' |
|
. Util::backquote('mysql') . '.' |
|
. Util::backquote('procs_priv') |
|
. ' VALUES("' . $priv[0] . '", "' |
|
. $priv[1] . '", "' . $priv[2] . '", "' |
|
. $_POST['item_name'] . '", "' |
|
. $_POST['item_type'] . '", "' |
|
. $priv[5] . '", "' |
|
. $priv[6] . '", "' |
|
. $priv[7] . '");'; |
|
$this->dbi->query($adjustProcPrivilege); |
|
$resultAdjust = true; |
|
} |
|
} |
|
|
|
$message = $this->flushPrivileges($resultAdjust); |
|
|
|
return [ |
|
[], |
|
$message, |
|
]; |
|
} |
|
|
|
/** |
|
* Flush privileges and get message |
|
* |
|
* @param bool $flushPrivileges Flush privileges |
|
* |
|
* @return Message |
|
*/ |
|
public function flushPrivileges($flushPrivileges) |
|
{ |
|
if ($flushPrivileges) { |
|
// Flush the Privileges |
|
$flushPrivQuery = 'FLUSH PRIVILEGES;'; |
|
$this->dbi->query($flushPrivQuery); |
|
|
|
$message = Message::success( |
|
__( |
|
'Routine %1$s has been modified. Privileges have been adjusted.' |
|
) |
|
); |
|
} else { |
|
$message = Message::success( |
|
__('Routine %1$s has been modified.') |
|
); |
|
} |
|
|
|
$message->addParam( |
|
Util::backquote($_POST['item_name']) |
|
); |
|
|
|
return $message; |
|
} |
|
|
|
/** |
|
* This function will generate the values that are required to |
|
* complete the editor form. It is especially necessary to handle |
|
* the 'Add another parameter', 'Remove last parameter' and |
|
* 'Change routine type' functionalities when JS is disabled. |
|
* |
|
* @return array Data necessary to create the routine editor. |
|
*/ |
|
public function getDataFromRequest() |
|
{ |
|
$retval = []; |
|
$indices = [ |
|
'item_name', |
|
'item_original_name', |
|
'item_returnlength', |
|
'item_returnopts_num', |
|
'item_returnopts_text', |
|
'item_definition', |
|
'item_comment', |
|
'item_definer', |
|
]; |
|
foreach ($indices as $index) { |
|
$retval[$index] = $_POST[$index] ?? ''; |
|
} |
|
|
|
$retval['item_type'] = 'PROCEDURE'; |
|
$retval['item_type_toggle'] = 'FUNCTION'; |
|
if (isset($_POST['item_type']) && $_POST['item_type'] === 'FUNCTION') { |
|
$retval['item_type'] = 'FUNCTION'; |
|
$retval['item_type_toggle'] = 'PROCEDURE'; |
|
} |
|
|
|
$retval['item_original_type'] = 'PROCEDURE'; |
|
if (isset($_POST['item_original_type']) && $_POST['item_original_type'] === 'FUNCTION') { |
|
$retval['item_original_type'] = 'FUNCTION'; |
|
} |
|
|
|
$retval['item_num_params'] = 0; |
|
$retval['item_param_dir'] = []; |
|
$retval['item_param_name'] = []; |
|
$retval['item_param_type'] = []; |
|
$retval['item_param_length'] = []; |
|
$retval['item_param_opts_num'] = []; |
|
$retval['item_param_opts_text'] = []; |
|
if ( |
|
isset($_POST['item_param_name'], $_POST['item_param_type']) |
|
&& isset($_POST['item_param_length']) |
|
&& isset($_POST['item_param_opts_num']) |
|
&& isset($_POST['item_param_opts_text']) |
|
&& is_array($_POST['item_param_name']) |
|
&& is_array($_POST['item_param_type']) |
|
&& is_array($_POST['item_param_length']) |
|
&& is_array($_POST['item_param_opts_num']) |
|
&& is_array($_POST['item_param_opts_text']) |
|
) { |
|
if ($_POST['item_type'] === 'PROCEDURE') { |
|
$retval['item_param_dir'] = $_POST['item_param_dir']; |
|
foreach ($retval['item_param_dir'] as $key => $value) { |
|
if (in_array($value, $this->directions, true)) { |
|
continue; |
|
} |
|
|
|
$retval['item_param_dir'][$key] = ''; |
|
} |
|
} |
|
|
|
$retval['item_param_name'] = $_POST['item_param_name']; |
|
$retval['item_param_type'] = $_POST['item_param_type']; |
|
foreach ($retval['item_param_type'] as $key => $value) { |
|
if (in_array($value, Util::getSupportedDatatypes(), true)) { |
|
continue; |
|
} |
|
|
|
$retval['item_param_type'][$key] = ''; |
|
} |
|
|
|
$retval['item_param_length'] = $_POST['item_param_length']; |
|
$retval['item_param_opts_num'] = $_POST['item_param_opts_num']; |
|
$retval['item_param_opts_text'] = $_POST['item_param_opts_text']; |
|
$retval['item_num_params'] = max( |
|
count($retval['item_param_name']), |
|
count($retval['item_param_type']), |
|
count($retval['item_param_length']), |
|
count($retval['item_param_opts_num']), |
|
count($retval['item_param_opts_text']) |
|
); |
|
} |
|
|
|
$retval['item_returntype'] = ''; |
|
if (isset($_POST['item_returntype']) && in_array($_POST['item_returntype'], Util::getSupportedDatatypes())) { |
|
$retval['item_returntype'] = $_POST['item_returntype']; |
|
} |
|
|
|
$retval['item_isdeterministic'] = ''; |
|
if (isset($_POST['item_isdeterministic']) && mb_strtolower($_POST['item_isdeterministic']) === 'on') { |
|
$retval['item_isdeterministic'] = " checked='checked'"; |
|
} |
|
|
|
$retval['item_securitytype_definer'] = ''; |
|
$retval['item_securitytype_invoker'] = ''; |
|
if (isset($_POST['item_securitytype'])) { |
|
if ($_POST['item_securitytype'] === 'DEFINER') { |
|
$retval['item_securitytype_definer'] = " selected='selected'"; |
|
} elseif ($_POST['item_securitytype'] === 'INVOKER') { |
|
$retval['item_securitytype_invoker'] = " selected='selected'"; |
|
} |
|
} |
|
|
|
$retval['item_sqldataaccess'] = ''; |
|
if (isset($_POST['item_sqldataaccess']) && in_array($_POST['item_sqldataaccess'], $this->sqlDataAccess, true)) { |
|
$retval['item_sqldataaccess'] = $_POST['item_sqldataaccess']; |
|
} |
|
|
|
return $retval; |
|
} |
|
|
|
/** |
|
* This function will generate the values that are required to complete |
|
* the "Edit routine" form given the name of a routine. |
|
* |
|
* @param string $name The name of the routine. |
|
* @param string $type Type of routine (ROUTINE|PROCEDURE) |
|
* @param bool $all Whether to return all data or just the info about parameters. |
|
* |
|
* @return array|null Data necessary to create the routine editor. |
|
*/ |
|
public function getDataFromName($name, $type, $all = true): ?array |
|
{ |
|
global $db; |
|
|
|
$retval = []; |
|
|
|
// Build and execute the query |
|
$fields = 'SPECIFIC_NAME, ROUTINE_TYPE, DTD_IDENTIFIER, ' |
|
. 'ROUTINE_DEFINITION, IS_DETERMINISTIC, SQL_DATA_ACCESS, ' |
|
. 'ROUTINE_COMMENT, SECURITY_TYPE'; |
|
$where = 'ROUTINE_SCHEMA ' . Util::getCollateForIS() . '=' |
|
. "'" . $this->dbi->escapeString($db) . "' " |
|
. "AND SPECIFIC_NAME='" . $this->dbi->escapeString($name) . "'" |
|
. "AND ROUTINE_TYPE='" . $this->dbi->escapeString($type) . "'"; |
|
$query = 'SELECT ' . $fields . ' FROM INFORMATION_SCHEMA.ROUTINES WHERE ' . $where . ';'; |
|
|
|
$routine = $this->dbi->fetchSingleRow($query); |
|
|
|
if (! $routine) { |
|
return null; |
|
} |
|
|
|
// Get required data |
|
$retval['item_name'] = $routine['SPECIFIC_NAME']; |
|
$retval['item_type'] = $routine['ROUTINE_TYPE']; |
|
|
|
$definition = $this->dbi->getDefinition($db, $routine['ROUTINE_TYPE'], $routine['SPECIFIC_NAME']); |
|
|
|
if ($definition === null) { |
|
return null; |
|
} |
|
|
|
$parser = new Parser($definition); |
|
|
|
/** |
|
* @var CreateStatement $stmt |
|
*/ |
|
$stmt = $parser->statements[0]; |
|
|
|
// Do not use $routine['ROUTINE_DEFINITION'] because of a MySQL escaping issue: #15370 |
|
$body = TokensList::build($stmt->body); |
|
if (empty($body)) { |
|
// Fallback just in case the parser fails |
|
$body = (string) $routine['ROUTINE_DEFINITION']; |
|
} |
|
|
|
$params = Routine::getParameters($stmt); |
|
$retval['item_num_params'] = $params['num']; |
|
$retval['item_param_dir'] = $params['dir']; |
|
$retval['item_param_name'] = $params['name']; |
|
$retval['item_param_type'] = $params['type']; |
|
$retval['item_param_length'] = $params['length']; |
|
$retval['item_param_length_arr'] = $params['length_arr']; |
|
$retval['item_param_opts_num'] = $params['opts']; |
|
$retval['item_param_opts_text'] = $params['opts']; |
|
|
|
// Get extra data |
|
if (! $all) { |
|
return $retval; |
|
} |
|
|
|
if ($retval['item_type'] === 'FUNCTION') { |
|
$retval['item_type_toggle'] = 'PROCEDURE'; |
|
} else { |
|
$retval['item_type_toggle'] = 'FUNCTION'; |
|
} |
|
|
|
$retval['item_returntype'] = ''; |
|
$retval['item_returnlength'] = ''; |
|
$retval['item_returnopts_num'] = ''; |
|
$retval['item_returnopts_text'] = ''; |
|
|
|
if (! empty($routine['DTD_IDENTIFIER'])) { |
|
$options = []; |
|
foreach ($stmt->return->options->options as $opt) { |
|
$options[] = is_string($opt) ? $opt : $opt['value']; |
|
} |
|
|
|
$retval['item_returntype'] = $stmt->return->name; |
|
$retval['item_returnlength'] = implode(',', $stmt->return->parameters); |
|
$retval['item_returnopts_num'] = implode(' ', $options); |
|
$retval['item_returnopts_text'] = implode(' ', $options); |
|
} |
|
|
|
$retval['item_definer'] = $stmt->options->has('DEFINER'); |
|
$retval['item_definition'] = $body; |
|
$retval['item_isdeterministic'] = ''; |
|
if ($routine['IS_DETERMINISTIC'] === 'YES') { |
|
$retval['item_isdeterministic'] = " checked='checked'"; |
|
} |
|
|
|
$retval['item_securitytype_definer'] = ''; |
|
$retval['item_securitytype_invoker'] = ''; |
|
if ($routine['SECURITY_TYPE'] === 'DEFINER') { |
|
$retval['item_securitytype_definer'] = " selected='selected'"; |
|
} elseif ($routine['SECURITY_TYPE'] === 'INVOKER') { |
|
$retval['item_securitytype_invoker'] = " selected='selected'"; |
|
} |
|
|
|
$retval['item_sqldataaccess'] = $routine['SQL_DATA_ACCESS']; |
|
$retval['item_comment'] = $routine['ROUTINE_COMMENT']; |
|
|
|
return $retval; |
|
} |
|
|
|
/** |
|
* Creates one row for the parameter table used in the routine editor. |
|
* |
|
* @param array $routine Data for the routine returned by |
|
* getDataFromRequest() or getDataFromName() |
|
* @param mixed $index Either a numeric index of the row being processed |
|
* or NULL to create a template row for AJAX request |
|
* @param string $class Class used to hide the direction column, if the |
|
* row is for a stored function. |
|
* |
|
* @return string HTML code of one row of parameter table for the editor. |
|
*/ |
|
public function getParameterRow(array $routine = [], $index = null, $class = '') |
|
{ |
|
if ($index === null) { |
|
// template row for AJAX request |
|
$i = 0; |
|
$index = '%s'; |
|
$drop_class = ''; |
|
$routine = [ |
|
'item_param_dir' => [0 => ''], |
|
'item_param_name' => [0 => ''], |
|
'item_param_type' => [0 => ''], |
|
'item_param_length' => [0 => ''], |
|
'item_param_opts_num' => [0 => ''], |
|
'item_param_opts_text' => [0 => ''], |
|
]; |
|
} elseif (! empty($routine)) { |
|
// regular row for routine editor |
|
$drop_class = ' hide'; |
|
$i = $index; |
|
} else { |
|
// No input data. This shouldn't happen, |
|
// but better be safe than sorry. |
|
return ''; |
|
} |
|
|
|
$allCharsets = Charsets::getCharsets($this->dbi, $GLOBALS['cfg']['Server']['DisableIS']); |
|
$charsets = []; |
|
foreach ($allCharsets as $charset) { |
|
$charsets[] = [ |
|
'name' => $charset->getName(), |
|
'description' => $charset->getDescription(), |
|
'is_selected' => $charset->getName() === $routine['item_param_opts_text'][$i], |
|
]; |
|
} |
|
|
|
return $this->template->render('database/routines/parameter_row', [ |
|
'class' => $class, |
|
'index' => $index, |
|
'param_directions' => $this->directions, |
|
'param_opts_num' => $this->numericOptions, |
|
'item_param_dir' => $routine['item_param_dir'][$i] ?? '', |
|
'item_param_name' => $routine['item_param_name'][$i] ?? '', |
|
'item_param_length' => $routine['item_param_length'][$i] ?? '', |
|
'item_param_opts_num' => $routine['item_param_opts_num'][$i] ?? '', |
|
'supported_datatypes' => Util::getSupportedDatatypes( |
|
true, |
|
$routine['item_param_type'][$i] |
|
), |
|
'charsets' => $charsets, |
|
'drop_class' => $drop_class, |
|
]); |
|
} |
|
|
|
/** |
|
* Displays a form used to add/edit a routine |
|
* |
|
* @param string $mode If the editor will be used to edit a routine |
|
* or add a new one: 'edit' or 'add'. |
|
* @param string $operation If the editor was previously invoked with |
|
* JS turned off, this will hold the name of |
|
* the current operation |
|
* @param array $routine Data for the routine returned by |
|
* getDataFromRequest() or getDataFromName() |
|
* |
|
* @return string HTML code for the editor. |
|
*/ |
|
public function getEditorForm($mode, $operation, array $routine) |
|
{ |
|
global $db, $errors; |
|
|
|
for ($i = 0; $i < $routine['item_num_params']; $i++) { |
|
$routine['item_param_name'][$i] = htmlentities($routine['item_param_name'][$i], ENT_QUOTES); |
|
$routine['item_param_length'][$i] = htmlentities($routine['item_param_length'][$i], ENT_QUOTES); |
|
} |
|
|
|
// Handle some logic first |
|
if ($operation === 'change') { |
|
if ($routine['item_type'] === 'PROCEDURE') { |
|
$routine['item_type'] = 'FUNCTION'; |
|
$routine['item_type_toggle'] = 'PROCEDURE'; |
|
} else { |
|
$routine['item_type'] = 'PROCEDURE'; |
|
$routine['item_type_toggle'] = 'FUNCTION'; |
|
} |
|
} elseif ($operation === 'add' || ($routine['item_num_params'] == 0 && $mode === 'add' && ! $errors)) { |
|
$routine['item_param_dir'][] = ''; |
|
$routine['item_param_name'][] = ''; |
|
$routine['item_param_type'][] = ''; |
|
$routine['item_param_length'][] = ''; |
|
$routine['item_param_opts_num'][] = ''; |
|
$routine['item_param_opts_text'][] = ''; |
|
$routine['item_num_params']++; |
|
} elseif ($operation === 'remove') { |
|
unset( |
|
$routine['item_param_dir'][$routine['item_num_params'] - 1], |
|
$routine['item_param_name'][$routine['item_num_params'] - 1], |
|
$routine['item_param_type'][$routine['item_num_params'] - 1], |
|
$routine['item_param_length'][$routine['item_num_params'] - 1], |
|
$routine['item_param_opts_num'][$routine['item_num_params'] - 1], |
|
$routine['item_param_opts_text'][$routine['item_num_params'] - 1] |
|
); |
|
$routine['item_num_params']--; |
|
} |
|
|
|
$parameterRows = ''; |
|
for ($i = 0; $i < $routine['item_num_params']; $i++) { |
|
$parameterRows .= $this->getParameterRow($routine, $i, $routine['item_type'] === 'FUNCTION' ? ' hide' : ''); |
|
} |
|
|
|
$charsets = Charsets::getCharsets($this->dbi, $GLOBALS['cfg']['Server']['DisableIS']); |
|
|
|
return $this->template->render('database/routines/editor_form', [ |
|
'db' => $db, |
|
'routine' => $routine, |
|
'is_edit_mode' => $mode === 'edit', |
|
'is_ajax' => $this->response->isAjax(), |
|
'parameter_rows' => $parameterRows, |
|
'charsets' => $charsets, |
|
'numeric_options' => $this->numericOptions, |
|
'has_privileges' => $GLOBALS['proc_priv'] && $GLOBALS['is_reload_priv'], |
|
'sql_data_access' => $this->sqlDataAccess, |
|
]); |
|
} |
|
|
|
/** |
|
* Set the found errors and build the params |
|
* |
|
* @param string[] $itemParamName The parameter names |
|
* @param string[] $itemParamDir The direction parameter (see $this->directions) |
|
* @param array $itemParamType The parameter type |
|
* @param array $itemParamLength A length or not for the parameter |
|
* @param array $itemParamOpsText An optional charset for the parameter |
|
* @param array $itemParamOpsNum An optional parameter for a $itemParamType NUMBER |
|
* @param string $itemType The item type (PROCEDURE/FUNCTION) |
|
* @param bool $warnedAboutLength A boolean that will be switched if a the length warning is given |
|
*/ |
|
private function processParamsAndBuild( |
|
array $itemParamName, |
|
array $itemParamDir, |
|
array $itemParamType, |
|
array $itemParamLength, |
|
array $itemParamOpsText, |
|
array $itemParamOpsNum, |
|
string $itemType, |
|
bool &$warnedAboutLength |
|
): string { |
|
global $errors, $dbi; |
|
|
|
$params = ''; |
|
$warnedAboutDir = false; |
|
|
|
for ($i = 0, $nb = count($itemParamName); $i < $nb; $i++) { |
|
if (empty($itemParamName[$i]) || empty($itemParamType[$i])) { |
|
$errors[] = __('You must provide a name and a type for each routine parameter.'); |
|
break; |
|
} |
|
|
|
if ( |
|
$itemType === 'PROCEDURE' |
|
&& ! empty($itemParamDir[$i]) |
|
&& in_array($itemParamDir[$i], $this->directions) |
|
) { |
|
$params .= $itemParamDir[$i] . ' ' |
|
. Util::backquote($itemParamName[$i]) |
|
. ' ' . $itemParamType[$i]; |
|
} elseif ($itemType === 'FUNCTION') { |
|
$params .= Util::backquote($itemParamName[$i]) |
|
. ' ' . $itemParamType[$i]; |
|
} elseif (! $warnedAboutDir) { |
|
$warnedAboutDir = true; |
|
$errors[] = sprintf( |
|
__('Invalid direction "%s" given for parameter.'), |
|
htmlspecialchars($itemParamDir[$i]) |
|
); |
|
} |
|
|
|
if ( |
|
$itemParamLength[$i] != '' |
|
&& ! preg_match( |
|
'@^(DATE|TINYBLOB|TINYTEXT|BLOB|TEXT|MEDIUMBLOB|MEDIUMTEXT|LONGBLOB|LONGTEXT|SERIAL|BOOLEAN)$@i', |
|
$itemParamType[$i] |
|
) |
|
) { |
|
$params .= '(' . $itemParamLength[$i] . ')'; |
|
} elseif ( |
|
$itemParamLength[$i] == '' |
|
&& preg_match('@^(ENUM|SET|VARCHAR|VARBINARY)$@i', $itemParamType[$i]) |
|
) { |
|
if (! $warnedAboutLength) { |
|
$warnedAboutLength = true; |
|
$errors[] = __( |
|
'You must provide length/values for routine parameters' |
|
. ' of type ENUM, SET, VARCHAR and VARBINARY.' |
|
); |
|
} |
|
} |
|
|
|
if (! empty($itemParamOpsText[$i])) { |
|
if ($dbi->types->getTypeClass($itemParamType[$i]) === 'CHAR') { |
|
if (! in_array($itemParamType[$i], ['VARBINARY', 'BINARY'])) { |
|
$params .= ' CHARSET ' |
|
. mb_strtolower($itemParamOpsText[$i]); |
|
} |
|
} |
|
} |
|
|
|
if (! empty($itemParamOpsNum[$i])) { |
|
if ($dbi->types->getTypeClass($itemParamType[$i]) === 'NUMBER') { |
|
$params .= ' ' |
|
. mb_strtoupper($itemParamOpsNum[$i]); |
|
} |
|
} |
|
|
|
if ($i == count($itemParamName) - 1) { |
|
continue; |
|
} |
|
|
|
$params .= ', '; |
|
} |
|
|
|
return $params; |
|
} |
|
|
|
/** |
|
* Set the found errors and build the query |
|
* |
|
* @param string $query The existing query |
|
* @param bool $warnedAboutLength If the length warning was given |
|
*/ |
|
private function processFunctionSpecificParameters( |
|
string $query, |
|
bool $warnedAboutLength |
|
): string { |
|
global $errors, $dbi; |
|
|
|
$itemReturnType = $_POST['item_returntype'] ?? null; |
|
|
|
if (! empty($itemReturnType) && in_array($itemReturnType, Util::getSupportedDatatypes())) { |
|
$query .= 'RETURNS ' . $itemReturnType; |
|
} else { |
|
$errors[] = __('You must provide a valid return type for the routine.'); |
|
} |
|
|
|
if ( |
|
! empty($_POST['item_returnlength']) |
|
&& ! preg_match( |
|
'@^(DATE|DATETIME|TIME|TINYBLOB|TINYTEXT|BLOB|TEXT|' |
|
. 'MEDIUMBLOB|MEDIUMTEXT|LONGBLOB|LONGTEXT|SERIAL|BOOLEAN)$@i', |
|
$itemReturnType |
|
) |
|
) { |
|
$query .= '(' . $_POST['item_returnlength'] . ')'; |
|
} elseif ( |
|
empty($_POST['item_returnlength']) |
|
&& preg_match('@^(ENUM|SET|VARCHAR|VARBINARY)$@i', $itemReturnType) |
|
) { |
|
if (! $warnedAboutLength) { |
|
$errors[] = __( |
|
'You must provide length/values for routine parameters of type ENUM, SET, VARCHAR and VARBINARY.' |
|
); |
|
} |
|
} |
|
|
|
if (! empty($_POST['item_returnopts_text'])) { |
|
if ($dbi->types->getTypeClass($itemReturnType) === 'CHAR') { |
|
$query .= ' CHARSET ' |
|
. mb_strtolower($_POST['item_returnopts_text']); |
|
} |
|
} |
|
|
|
if (! empty($_POST['item_returnopts_num'])) { |
|
if ($dbi->types->getTypeClass($itemReturnType) === 'NUMBER') { |
|
$query .= ' ' |
|
. mb_strtoupper($_POST['item_returnopts_num']); |
|
} |
|
} |
|
|
|
return $query . ' '; |
|
} |
|
|
|
/** |
|
* Composes the query necessary to create a routine from an HTTP request. |
|
* |
|
* @return string The CREATE [ROUTINE | PROCEDURE] query. |
|
*/ |
|
public function getQueryFromRequest(): string |
|
{ |
|
global $errors; |
|
|
|
$itemType = $_POST['item_type'] ?? ''; |
|
$itemDefiner = $_POST['item_definer'] ?? ''; |
|
$itemName = $_POST['item_name'] ?? ''; |
|
|
|
$query = 'CREATE '; |
|
if (! empty($itemDefiner)) { |
|
if (str_contains($itemDefiner, '@')) { |
|
$arr = explode('@', $itemDefiner); |
|
|
|
$do_backquote = true; |
|
if (substr($arr[0], 0, 1) === '`' && substr($arr[0], -1) === '`') { |
|
$do_backquote = false; |
|
} |
|
|
|
$query .= 'DEFINER=' . Util::backquoteCompat($arr[0], 'NONE', $do_backquote); |
|
|
|
$do_backquote = true; |
|
if (substr($arr[1], 0, 1) === '`' && substr($arr[1], -1) === '`') { |
|
$do_backquote = false; |
|
} |
|
|
|
$query .= '@' . Util::backquoteCompat($arr[1], 'NONE', $do_backquote) . ' '; |
|
} else { |
|
$errors[] = __('The definer must be in the "username@hostname" format!'); |
|
} |
|
} |
|
|
|
if ($itemType === 'FUNCTION' || $itemType === 'PROCEDURE') { |
|
$query .= $itemType . ' '; |
|
} else { |
|
$errors[] = sprintf( |
|
__('Invalid routine type: "%s"'), |
|
htmlspecialchars($itemType) |
|
); |
|
} |
|
|
|
if (! empty($itemName)) { |
|
$query .= Util::backquote($itemName); |
|
} else { |
|
$errors[] = __('You must provide a routine name!'); |
|
} |
|
|
|
$warnedAboutLength = false; |
|
|
|
$itemParamName = $_POST['item_param_name'] ?? ''; |
|
$itemParamType = $_POST['item_param_type'] ?? ''; |
|
$itemParamLength = $_POST['item_param_length'] ?? ''; |
|
$itemParamDir = (array) ($_POST['item_param_dir'] ?? []); |
|
$itemParamOpsText = (array) ($_POST['item_param_opts_text'] ?? []); |
|
$itemParamOpsNum = (array) ($_POST['item_param_opts_num'] ?? []); |
|
|
|
$params = ''; |
|
if ( |
|
! empty($itemParamName) |
|
&& ! empty($itemParamType) |
|
&& ! empty($itemParamLength) |
|
&& is_array($itemParamName) |
|
&& is_array($itemParamType) |
|
&& is_array($itemParamLength) |
|
) { |
|
$params = $this->processParamsAndBuild( |
|
$itemParamName, |
|
$itemParamDir, |
|
$itemParamType, |
|
$itemParamLength, |
|
$itemParamOpsText, |
|
$itemParamOpsNum, |
|
$itemType, |
|
$warnedAboutLength// Will possibly be modified by the function |
|
); |
|
} |
|
|
|
$query .= '(' . $params . ') '; |
|
if ($itemType === 'FUNCTION') { |
|
$query = $this->processFunctionSpecificParameters($query, $warnedAboutLength); |
|
} |
|
|
|
if (! empty($_POST['item_comment'])) { |
|
$query .= "COMMENT '" . $this->dbi->escapeString($_POST['item_comment']) |
|
. "' "; |
|
} |
|
|
|
if (isset($_POST['item_isdeterministic'])) { |
|
$query .= 'DETERMINISTIC '; |
|
} else { |
|
$query .= 'NOT DETERMINISTIC '; |
|
} |
|
|
|
$itemSqlDataAccess = $_POST['item_sqldataaccess'] ?? ''; |
|
if (! empty($itemSqlDataAccess) && in_array($itemSqlDataAccess, $this->sqlDataAccess)) { |
|
$query .= $itemSqlDataAccess . ' '; |
|
} |
|
|
|
$itemSecurityType = $_POST['item_securitytype'] ?? ''; |
|
if (! empty($itemSecurityType)) { |
|
if ($itemSecurityType === 'DEFINER' || $itemSecurityType === 'INVOKER') { |
|
$query .= 'SQL SECURITY ' . $itemSecurityType . ' '; |
|
} |
|
} |
|
|
|
$itemDefinition = $_POST['item_definition'] ?? ''; |
|
if (! empty($itemDefinition)) { |
|
$query .= $itemDefinition; |
|
} else { |
|
$errors[] = __('You must provide a routine definition.'); |
|
} |
|
|
|
return $query; |
|
} |
|
|
|
/** |
|
* @see handleExecuteRoutine |
|
* |
|
* @param array $routine The routine params |
|
* |
|
* @return string[] The SQL queries / SQL query parts |
|
*/ |
|
private function getQueriesFromRoutineForm(array $routine): array |
|
{ |
|
$queries = []; |
|
$end_query = []; |
|
$args = []; |
|
$all_functions = $this->dbi->types->getAllFunctions(); |
|
for ($i = 0; $i < $routine['item_num_params']; $i++) { |
|
if (isset($_POST['params'][$routine['item_param_name'][$i]])) { |
|
$value = $_POST['params'][$routine['item_param_name'][$i]]; |
|
if (is_array($value)) { // is SET type |
|
$value = implode(',', $value); |
|
} |
|
|
|
$value = $this->dbi->escapeString($value); |
|
if ( |
|
! empty($_POST['funcs'][$routine['item_param_name'][$i]]) |
|
&& in_array($_POST['funcs'][$routine['item_param_name'][$i]], $all_functions) |
|
) { |
|
$queries[] = 'SET @p' . $i . '=' |
|
. $_POST['funcs'][$routine['item_param_name'][$i]] |
|
. "('" . $value . "');\n"; |
|
} else { |
|
$queries[] = 'SET @p' . $i . "='" . $value . "';\n"; |
|
} |
|
|
|
$args[] = '@p' . $i; |
|
} else { |
|
$args[] = '@p' . $i; |
|
} |
|
|
|
if ($routine['item_type'] !== 'PROCEDURE') { |
|
continue; |
|
} |
|
|
|
if ($routine['item_param_dir'][$i] !== 'OUT' && $routine['item_param_dir'][$i] !== 'INOUT') { |
|
continue; |
|
} |
|
|
|
$end_query[] = '@p' . $i . ' AS ' |
|
. Util::backquote($routine['item_param_name'][$i]); |
|
} |
|
|
|
if ($routine['item_type'] === 'PROCEDURE') { |
|
$queries[] = 'CALL ' . Util::backquote($routine['item_name']) |
|
. '(' . implode(', ', $args) . ");\n"; |
|
if (count($end_query)) { |
|
$queries[] = 'SELECT ' . implode(', ', $end_query) . ";\n"; |
|
} |
|
} else { |
|
$queries[] = 'SELECT ' . Util::backquote($routine['item_name']) |
|
. '(' . implode(', ', $args) . ') ' |
|
. 'AS ' . Util::backquote($routine['item_name']) |
|
. ";\n"; |
|
} |
|
|
|
return $queries; |
|
} |
|
|
|
private function handleExecuteRoutine(): void |
|
{ |
|
global $db; |
|
|
|
// Build the queries |
|
$routine = $this->getDataFromName($_POST['item_name'], $_POST['item_type'], false); |
|
if ($routine === null) { |
|
$message = __('Error in processing request:') . ' '; |
|
$message .= sprintf( |
|
__('No routine with name %1$s found in database %2$s.'), |
|
htmlspecialchars(Util::backquote($_POST['item_name'])), |
|
htmlspecialchars(Util::backquote($db)) |
|
); |
|
$message = Message::error($message); |
|
if ($this->response->isAjax()) { |
|
$this->response->setRequestStatus(false); |
|
$this->response->addJSON('message', $message); |
|
exit; |
|
} |
|
|
|
echo $message->getDisplay(); |
|
unset($_POST); |
|
//NOTE: Missing exit ? |
|
} |
|
|
|
$queries = is_array($routine) ? $this->getQueriesFromRoutineForm($routine) : []; |
|
|
|
// Get all the queries as one SQL statement |
|
$multiple_query = implode('', $queries); |
|
|
|
$outcome = true; |
|
$affected = 0; |
|
|
|
// Execute query |
|
if (! $this->dbi->tryMultiQuery($multiple_query)) { |
|
$outcome = false; |
|
} |
|
|
|
// Generate output |
|
$output = ''; |
|
$nbResultsetToDisplay = 0; |
|
if ($outcome) { |
|
// Pass the SQL queries through the "pretty printer" |
|
$output = Generator::formatSql(implode("\n", $queries)); |
|
|
|
// Display results |
|
$output .= '<div class="card my-3"><div class="card-header">'; |
|
$output .= sprintf( |
|
__('Execution results of routine %s'), |
|
Util::backquote(htmlspecialchars($routine['item_name'])) |
|
); |
|
$output .= '</div><div class="card-body">'; |
|
|
|
do { |
|
$result = $this->dbi->storeResult(); |
|
|
|
if ($result !== false && $result->numRows() > 0) { |
|
$output .= '<table class="table table-light table-striped w-auto"><tr>'; |
|
foreach ($result->getFieldNames() as $field) { |
|
$output .= '<th>'; |
|
$output .= htmlspecialchars($field); |
|
$output .= '</th>'; |
|
} |
|
|
|
$output .= '</tr>'; |
|
|
|
foreach ($result as $row) { |
|
$output .= '<tr>' . $this->browseRow($row) . '</tr>'; |
|
} |
|
|
|
$output .= '</table>'; |
|
$nbResultsetToDisplay++; |
|
$affected = $result->numRows(); |
|
} |
|
|
|
if (! $this->dbi->moreResults()) { |
|
break; |
|
} |
|
|
|
unset($result); |
|
|
|
$outcome = $this->dbi->nextResult(); |
|
} while ($outcome); |
|
} |
|
|
|
if ($outcome) { |
|
$output .= '</div></div>'; |
|
|
|
$message = __('Your SQL query has been executed successfully.'); |
|
if ($routine['item_type'] === 'PROCEDURE') { |
|
$message .= '<br>'; |
|
|
|
// TODO : message need to be modified according to the |
|
// output from the routine |
|
$message .= sprintf( |
|
_ngettext( |
|
'%d row affected by the last statement inside the procedure.', |
|
'%d rows affected by the last statement inside the procedure.', |
|
(int) $affected |
|
), |
|
$affected |
|
); |
|
} |
|
|
|
$message = Message::success($message); |
|
|
|
if ($nbResultsetToDisplay == 0) { |
|
$notice = __('MySQL returned an empty result set (i.e. zero rows).'); |
|
$output .= Message::notice($notice)->getDisplay(); |
|
} |
|
} else { |
|
$output = ''; |
|
$message = Message::error( |
|
sprintf( |
|
__('The following query has failed: "%s"'), |
|
htmlspecialchars($multiple_query) |
|
) |
|
. '<br><br>' |
|
. __('MySQL said: ') . $this->dbi->getError() |
|
); |
|
} |
|
|
|
// Print/send output |
|
if ($this->response->isAjax()) { |
|
$this->response->setRequestStatus($message->isSuccess()); |
|
$this->response->addJSON('message', $message->getDisplay() . $output); |
|
$this->response->addJSON('dialog', false); |
|
exit; |
|
} |
|
|
|
echo $message->getDisplay() , $output; |
|
if ($message->isError()) { |
|
// At least one query has failed, so shouldn't |
|
// execute any more queries, so we quit. |
|
exit; |
|
} |
|
|
|
unset($_POST); |
|
// Now deliberately fall through to displaying the routines list |
|
} |
|
|
|
/** |
|
* Handles requests for executing a routine |
|
*/ |
|
public function handleExecute(): void |
|
{ |
|
global $db; |
|
|
|
/** |
|
* Handle all user requests other than the default of listing routines |
|
*/ |
|
if (! empty($_POST['execute_routine']) && ! empty($_POST['item_name'])) { |
|
$this->handleExecuteRoutine(); |
|
} elseif (! empty($_GET['execute_dialog']) && ! empty($_GET['item_name'])) { |
|
/** |
|
* Display the execute form for a routine. |
|
*/ |
|
$routine = $this->getDataFromName($_GET['item_name'], $_GET['item_type'], true); |
|
if ($routine !== null) { |
|
$form = $this->getExecuteForm($routine); |
|
if ($this->response->isAjax()) { |
|
$title = __('Execute routine') . ' ' . Util::backquote( |
|
htmlentities($_GET['item_name'], ENT_QUOTES) |
|
); |
|
$this->response->addJSON('message', $form); |
|
$this->response->addJSON('title', $title); |
|
$this->response->addJSON('dialog', true); |
|
} else { |
|
echo "\n\n<h2>" . __('Execute routine') . "</h2>\n\n"; |
|
echo $form; |
|
} |
|
|
|
exit; |
|
} |
|
|
|
if ($this->response->isAjax()) { |
|
$message = __('Error in processing request:') . ' '; |
|
$message .= sprintf( |
|
__('No routine with name %1$s found in database %2$s.'), |
|
htmlspecialchars(Util::backquote($_GET['item_name'])), |
|
htmlspecialchars(Util::backquote($db)) |
|
); |
|
$message = Message::error($message); |
|
|
|
$this->response->setRequestStatus(false); |
|
$this->response->addJSON('message', $message); |
|
exit; |
|
} |
|
} |
|
} |
|
|
|
/** |
|
* Browse row array |
|
* |
|
* @param array $row Columns |
|
*/ |
|
private function browseRow(array $row): ?string |
|
{ |
|
$output = null; |
|
foreach ($row as $value) { |
|
if ($value === null) { |
|
$value = '<i>NULL</i>'; |
|
} else { |
|
$value = htmlspecialchars($value); |
|
} |
|
|
|
$output .= '<td>' . $value . '</td>'; |
|
} |
|
|
|
return $output; |
|
} |
|
|
|
/** |
|
* Creates the HTML code that shows the routine execution dialog. |
|
* |
|
* @param array $routine Data for the routine returned by |
|
* getDataFromName() |
|
* |
|
* @return string HTML code for the routine execution dialog. |
|
*/ |
|
public function getExecuteForm(array $routine): string |
|
{ |
|
global $db, $cfg; |
|
|
|
// Escape special characters |
|
$routine['item_name'] = htmlentities($routine['item_name'], ENT_QUOTES); |
|
for ($i = 0; $i < $routine['item_num_params']; $i++) { |
|
$routine['item_param_name'][$i] = htmlentities($routine['item_param_name'][$i], ENT_QUOTES); |
|
} |
|
|
|
$no_support_types = Util::unsupportedDatatypes(); |
|
|
|
$params = []; |
|
$params['no_support_types'] = $no_support_types; |
|
|
|
for ($i = 0; $i < $routine['item_num_params']; $i++) { |
|
if ($routine['item_type'] === 'PROCEDURE' && $routine['item_param_dir'][$i] === 'OUT') { |
|
continue; |
|
} |
|
|
|
if ($cfg['ShowFunctionFields']) { |
|
if ( |
|
stripos($routine['item_param_type'][$i], 'enum') !== false |
|
|| stripos($routine['item_param_type'][$i], 'set') !== false |
|
|| in_array( |
|
mb_strtolower($routine['item_param_type'][$i]), |
|
$no_support_types |
|
) |
|
) { |
|
$params[$i]['generator'] = null; |
|
} else { |
|
$field = [ |
|
'True_Type' => mb_strtolower($routine['item_param_type'][$i]), |
|
'Type' => '', |
|
'Key' => '', |
|
'Field' => '', |
|
'Default' => '', |
|
'first_timestamp' => false, |
|
]; |
|
|
|
$generator = Generator::getFunctionsForField($field, false, []); |
|
$params[$i]['generator'] = $generator; |
|
} |
|
} |
|
|
|
if ($routine['item_param_type'][$i] === 'DATETIME' || $routine['item_param_type'][$i] === 'TIMESTAMP') { |
|
$params[$i]['class'] = 'datetimefield'; |
|
} elseif ($routine['item_param_type'][$i] === 'DATE') { |
|
$params[$i]['class'] = 'datefield'; |
|
} |
|
|
|
if (in_array($routine['item_param_type'][$i], ['ENUM', 'SET'])) { |
|
if ($routine['item_param_type'][$i] === 'ENUM') { |
|
$params[$i]['input_type'] = 'radio'; |
|
} else { |
|
$params[$i]['input_type'] = 'checkbox'; |
|
} |
|
|
|
foreach ($routine['item_param_length_arr'][$i] as $value) { |
|
$value = htmlentities(Util::unQuote($value), ENT_QUOTES); |
|
$params[$i]['htmlentities'][] = $value; |
|
} |
|
} elseif (in_array(mb_strtolower($routine['item_param_type'][$i]), $no_support_types)) { |
|
$params[$i]['input_type'] = null; |
|
} else { |
|
$params[$i]['input_type'] = 'text'; |
|
} |
|
} |
|
|
|
return $this->template->render('database/routines/execute_form', [ |
|
'db' => $db, |
|
'routine' => $routine, |
|
'ajax' => $this->response->isAjax(), |
|
'show_function_fields' => $cfg['ShowFunctionFields'], |
|
'params' => $params, |
|
]); |
|
} |
|
|
|
/** |
|
* Creates the contents for a row in the list of routines |
|
* |
|
* @param array $routine An array of routine data |
|
* @param string $rowClass Additional class |
|
* |
|
* @return string HTML code of a row for the list of routines |
|
*/ |
|
public function getRow(array $routine, $rowClass = '') |
|
{ |
|
global $db, $table; |
|
|
|
$sqlDrop = sprintf( |
|
'DROP %s IF EXISTS %s', |
|
$routine['type'], |
|
Util::backquote($routine['name']) |
|
); |
|
|
|
// this is for our purpose to decide whether to |
|
// show the edit link or not, so we need the DEFINER for the routine |
|
$where = 'ROUTINE_SCHEMA ' . Util::getCollateForIS() . '=' |
|
. "'" . $this->dbi->escapeString($db) . "' " |
|
. "AND SPECIFIC_NAME='" . $this->dbi->escapeString($routine['name']) . "'" |
|
. "AND ROUTINE_TYPE='" . $this->dbi->escapeString($routine['type']) . "'"; |
|
$query = 'SELECT `DEFINER` FROM INFORMATION_SCHEMA.ROUTINES WHERE ' . $where . ';'; |
|
$routineDefiner = $this->dbi->fetchValue($query); |
|
|
|
$currentUser = $this->dbi->getCurrentUser(); |
|
$currentUserIsRoutineDefiner = $currentUser === $routineDefiner; |
|
|
|
// Since editing a procedure involved dropping and recreating, check also for |
|
// CREATE ROUTINE privilege to avoid lost procedures. |
|
$hasCreateRoutine = Util::currentUserHasPrivilege('CREATE ROUTINE', $db); |
|
$hasEditPrivilege = ($hasCreateRoutine && $currentUserIsRoutineDefiner) |
|
|| $this->dbi->isSuperUser(); |
|
$hasExportPrivilege = ($hasCreateRoutine && $currentUserIsRoutineDefiner) |
|
|| $this->dbi->isSuperUser(); |
|
$hasExecutePrivilege = Util::currentUserHasPrivilege('EXECUTE', $db) |
|
|| $currentUserIsRoutineDefiner; |
|
|
|
// There is a problem with Util::currentUserHasPrivilege(): |
|
// it does not detect all kinds of privileges, for example |
|
// a direct privilege on a specific routine. So, at this point, |
|
// we show the Execute link, hoping that the user has the correct rights. |
|
// Also, information_schema might be hiding the ROUTINE_DEFINITION |
|
// but a routine with no input parameters can be nonetheless executed. |
|
|
|
// Check if the routine has any input parameters. If it does, |
|
// we will show a dialog to get values for these parameters, |
|
// otherwise we can execute it directly. |
|
|
|
$definition = $this->dbi->getDefinition($db, $routine['type'], $routine['name']); |
|
$executeAction = ''; |
|
|
|
if ($definition !== null) { |
|
$parser = new Parser($definition); |
|
|
|
/** |
|
* @var CreateStatement $stmt |
|
*/ |
|
$stmt = $parser->statements[0]; |
|
|
|
$params = Routine::getParameters($stmt); |
|
|
|
if ($hasExecutePrivilege) { |
|
$executeAction = 'execute_routine'; |
|
for ($i = 0; $i < $params['num']; $i++) { |
|
if ($routine['type'] === 'PROCEDURE' && $params['dir'][$i] === 'OUT') { |
|
continue; |
|
} |
|
|
|
$executeAction = 'execute_dialog'; |
|
break; |
|
} |
|
} |
|
} |
|
|
|
return $this->template->render('database/routines/row', [ |
|
'db' => $db, |
|
'table' => $table, |
|
'sql_drop' => $sqlDrop, |
|
'routine' => $routine, |
|
'row_class' => $rowClass, |
|
'has_edit_privilege' => $hasEditPrivilege, |
|
'has_export_privilege' => $hasExportPrivilege, |
|
'has_execute_privilege' => $hasExecutePrivilege, |
|
'execute_action' => $executeAction, |
|
]); |
|
} |
|
|
|
/** |
|
* @param string $createStatement Query |
|
* @param array $errors Errors |
|
* |
|
* @return array |
|
*/ |
|
private function checkResult($createStatement, array $errors) |
|
{ |
|
// OMG, this is really bad! We dropped the query, |
|
// failed to create a new one |
|
// and now even the backup query does not execute! |
|
// This should not happen, but we better handle |
|
// this just in case. |
|
$errors[] = __('Sorry, we failed to restore the dropped routine.') . '<br>' |
|
. __('The backed up query was:') |
|
. '"' . htmlspecialchars($createStatement) . '"<br>' |
|
. __('MySQL said: ') . $this->dbi->getError(); |
|
|
|
return $errors; |
|
} |
|
|
|
public function export(): void |
|
{ |
|
global $db; |
|
|
|
if (empty($_GET['export_item']) || empty($_GET['item_name']) || empty($_GET['item_type'])) { |
|
return; |
|
} |
|
|
|
if ($_GET['item_type'] !== 'FUNCTION' && $_GET['item_type'] !== 'PROCEDURE') { |
|
return; |
|
} |
|
|
|
$routineDefinition = $this->dbi->getDefinition($db, $_GET['item_type'], $_GET['item_name']); |
|
$exportData = false; |
|
|
|
if ($routineDefinition !== null) { |
|
$exportData = "DELIMITER $$\n" . $routineDefinition . "$$\nDELIMITER ;\n"; |
|
} |
|
|
|
$itemName = htmlspecialchars(Util::backquote($_GET['item_name'])); |
|
if ($exportData !== false) { |
|
$exportData = htmlspecialchars(trim($exportData)); |
|
$title = sprintf(__('Export of routine %s'), $itemName); |
|
|
|
if ($this->response->isAjax()) { |
|
$this->response->addJSON('message', $exportData); |
|
$this->response->addJSON('title', $title); |
|
|
|
exit; |
|
} |
|
|
|
$output = '<div class="container">'; |
|
$output .= '<h2>' . $title . '</h2>'; |
|
$output .= '<div class="card"><div class="card-body">'; |
|
$output .= '<textarea rows="15" class="form-control">' . $exportData . '</textarea>'; |
|
$output .= '</div></div></div>'; |
|
|
|
$this->response->addHTML($output); |
|
|
|
return; |
|
} |
|
|
|
$message = sprintf( |
|
__( |
|
'Error in processing request: No routine with name %1$s found in database %2$s.' |
|
. ' You might be lacking the necessary privileges to view/export this routine.' |
|
), |
|
$itemName, |
|
htmlspecialchars(Util::backquote($db)) |
|
); |
|
$message = Message::error($message); |
|
|
|
if ($this->response->isAjax()) { |
|
$this->response->setRequestStatus(false); |
|
$this->response->addJSON('message', $message); |
|
|
|
exit; |
|
} |
|
|
|
$this->response->addHTML($message->getDisplay()); |
|
} |
|
}
|
|
|