Переменные пользователя (слабая проверка). Переменные, использующие синтаксис $@variable_name (т.е. переменные пользователя), не проверяются. Сервер не выдает предупреждений или ошибок, если переменная имеет неправильный тип или ранее не была присвоена значение. Это также означает, что пользователь несет полную ответственность за любые опечатки, так как не выдается никаких предупреждений, если, например, используется $@myvairable вместо $@myvariable.

Пример:

mysql> SET @xml = '<a><b>X</b><b>Y</b></a>';
Query OK, 0 rows affected (0.00 sec)

mysql> SET @i =1, @j = 2;
Query OK, 0 rows affected (0.00 sec)

mysql> SELECT @i, ExtractValue(@xml, '//b[$@i]');
+------+--------------------------------+
| @i   | ExtractValue(@xml, '//b[$@i]') |
+------+--------------------------------+
|    1 | X                              |
+------+--------------------------------+
1 row in set (0.00 sec)

mysql> SELECT @j, ExtractValue(@xml, '//b[$@j]');
+------+--------------------------------+
| @j   | ExtractValue(@xml, '//b[$@j]') |
+------+--------------------------------+
|    2 | Y                              |
+------+--------------------------------+
1 row in set (0.00 sec)

mysql> SELECT @k, ExtractValue(@xml, '//b[$@k]');
+------+--------------------------------+
| @k   | ExtractValue(@xml, '//b[$@k]') |
+------+--------------------------------+
| NULL |                                |
+------+--------------------------------+
1 row in set (0.00 sec)

Переменные в хранимых программах (сильная проверка). Переменные, использующие синтаксис $variable_name, могут быть объявлены и использованы с этими функциями при вызове их внутри хранимых программ. Такие переменные локальны для хранимой программы, в которой они определены, и проверяются строго на тип и значение.

Пример:

mysql> DELIMITER |

mysql> CREATE PROCEDURE myproc ()
    -> BEGIN
    ->   DECLARE i INT DEFAULT 1;
    ->   DECLARE xml VARCHAR(25) DEFAULT '<a>X</a><a>Y</a><a>Z</a>';
    ->
    ->   WHILE i < 4 DO
    ->     SELECT xml, i, ExtractValue(xml, '//a[$i]');
    ->     SET i = i+1;
    ->   END WHILE;
    -> END |
Query OK, 0 rows affected (0.01 sec)

mysql> DELIMITER ;

mysql> CALL myproc();
+--------------------------+---+------------------------------+
| xml                      | i | ExtractValue(xml, '//a[$i]') |
+--------------------------+---+------------------------------+
| <a>X</a><a>Y</a><a>Z</a> | 1 | X                            |
+--------------------------+---+------------------------------+
1 row in set (0.00 sec)

+--------------------------+---+------------------------------+
| xml                      | i | ExtractValue(xml, '//a[$i]') |
+--------------------------+---+------------------------------+
| <a>X</a><a>Y</a><a>Z</a> | 2 | Y                            |
+--------------------------+---+------------------------------+
1 row in set (0.01 sec)

+--------------------------+---+------------------------------+
| xml                      | i | ExtractValue(xml, '//a[$i]') |
+--------------------------+---+------------------------------+
| <a>X</a><a>Y</a><a>Z</a> | 3 | Z                            |
+--------------------------+---+------------------------------+
1 row in set (0.01 sec)

Параметры. Переменные, используемые в XPath-выражениях внутри хранимых процедур, передаваемые в качестве параметров, также подвергаются строгой проверке.

ExtractValue(xml_frag, xpath_expr)

ExtractValue() принимает два строковых аргумента, фрагмент XML-разметки xml_frag и XPath-выражение xpath_expr (также известное как локализация); она возвращает текст (CDATA) первого текстового узла, который является потомком элемента или элементов, соответствующих XPath-выражению.

Использование этой функции эквивалентно выполнению соответствия с использованием xpath_expr после добавления /text(). Другими словами, ExtractValue('<a><b>Sakila</b></a>', '/a/b') и ExtractValue('<a><b>Sakila</b></a>', '/a/b/text()') дают одинаковый результат. Если xml_frag или xpath_expr является NULL, функция возвращает NULL.

Если найдено несколько совпадений, содержимое первого текстового узла потомков каждого соответствующего элемента возвращается (в порядке соответствия) как одна строка, разделенная пробелами.

Если для выражения не найдено ни одного соответствующего текстового узла (включая неявное /text()) — по любой причине, пока xpath_expr является допустимым, и xml_frag состоит из элементов, которые должным образом вложены и закрыты — возвращается пустая строка. Не делается различий между соответствием пустому элементу и полным отсутствием соответствия. Это сделано намеренно.

Если вам нужно определить, найдено ли несоответствие элементу в xml_frag или такой элемент был найден, но не содержал текстовых узлов потомков, вы должны проверить результат выражения, использующего XPath count() функцию. Например, оба этих утверждения возвращают пустую строку, как показано здесь:

mysql> SELECT ExtractValue('<a><b/></a>', '/a/b');
+-------------------------------------+
| ExtractValue('<a><b/></a>', '/a/b') |
+-------------------------------------+
|                                     |
+-------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT ExtractValue('<a><c/></a>', '/a/b');
+-------------------------------------+
| ExtractValue('<a><c/></a>', '/a/b') |
+-------------------------------------+
|                                     |
+-------------------------------------+
1 row in set (0.00 sec)

Однако вы можете определить, был ли фактически найден соответствующий элемент, используя следующее:

mysql> SELECT ExtractValue('<a><b/></a>', 'count(/a/b)');
+-------------------------------------+
| ExtractValue('<a><b/></a>', 'count(/a/b)') |
+-------------------------------------+
| 1                                   |
+-------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT ExtractValue('<a><c/></a>', 'count(/a/b)');
+-------------------------------------+
| ExtractValue('<a><c/></a>', 'count(/a/b)') |
+-------------------------------------+
| 0                                   |
+-------------------------------------+
1 row in set (0.01 sec)

mysql> SELECT
    ->   ExtractValue('<a>ccc<b>ddd</b></a>', '/a') AS val1,
    ->   ExtractValue('<a>ccc<b>ddd</b></a>', '/a/b') AS val2,
    ->   ExtractValue('<a>ccc<b>ddd</b></a>', '//b') AS val3,
    ->   ExtractValue('<a>ccc<b>ddd</b></a>', '/b') AS val4,
    ->   ExtractValue('<a>ccc<b>ddd</b><b>eee</b></a>', '//b') AS val5;

+------+------+------+------+---------+
| val1 | val2 | val3 | val4 | val5    |
+------+------+------+------+---------+
| ccc  | ddd  | ddd  |      | ddd eee |
+------+------+------+------+---------+

Эта функция использует текущую сортировку SQL для сравнения с contains(), выполняя ту же сортировку, что и другие строковые функции (например, CONCAT()), учитывая принудительную сортировку их аргументов; см. Раздел 12.8.4, «Принудительная сортировка в выражениях», для объяснения правил, управляющих этим поведением.

(Ранее всегда использовалось двоичное сравнение — то есть, чувствительное к регистру).

NULL возвращается, если xml_frag содержит элементы, которые не должным образом вложены или закрыты, и генерируется предупреждение, как показано в этом примере:

mysql> SELECT ExtractValue('<a>c</a><b', '//a');
+-----------------------------------+
| ExtractValue('<a>c</a><b', '//a') |
+-----------------------------------+
| NULL                              |
+-----------------------------------+
1 row in set, 1 warning (0.00 sec)

mysql> SHOW WARNINGS\G
*************************** 1. row ***************************
  Level: Warning
   Code: 1525
Message: Incorrect XML value: 'parse error at line 1 pos 11:
         END-OF-INPUT unexpected ('>' wanted)'
1 row in set (0.00 sec)

mysql> SELECT ExtractValue('<a>c</a><b/>', '//a');
+-------------------------------------+
| ExtractValue('<a>c</a><b/>', '//a') |
+-------------------------------------+
| c                                   |
+-------------------------------------+
1 row in set (0.00 sec)

UpdateXML(xml_target, xpath_expr, new_xml)

Эта функция заменяет одну часть заданного фрагмента XML-разметки xml_target новым XML-фрагментом new_xml и затем возвращает изменённый XML. Часть xml_target, которая заменяется, соответствует XPath-выражению xpath_expr, предоставленному пользователем.

Если не найдено никакого выражения, соответствующего xpath_expr, или если найдено несколько соответствий, функция возвращает исходный xml_target XML-фрагмент. Все три аргумента должны быть строками. Если любой из аргументов для UpdateXML() является NULL, функция возвращает NULL.

mysql> SELECT
    ->   UpdateXML('<a><b>ccc</b><d></d></a>', '/a', '<e>fff</e>') AS val1,
    ->   UpdateXML('<a><b>ccc</b><d></d></a>', '/b', '<e>fff</e>') AS val2,
    ->   UpdateXML('<a><b>ccc</b><d></d></a>', '//b', '<e>fff</e>') AS val3,
    ->   UpdateXML('<a><b>ccc</b><d></d></a>', '/a/d', '<e>fff</e>') AS val4,
    ->   UpdateXML('<a><d></d><b>ccc</b><d></d></a>', '/a/d', '<e>fff</e>') AS val5
    -> \G

*************************** 1. row ***************************
val1: <e>fff</e>
val2: <a><b>ccc</b><d></d></a>
val3: <a><e>fff</e><d></d></a>
val4: <a><b>ccc</b><e>fff</e></a>
val5: <a><d></d><b>ccc</b><d></d></a>

/tag

Совпадает с <tag/> только в том случае, если <tag/> является корневым элементом.

Пример: /a соответствует <a><b/></a>, потому что он соответствует самому внешнему (корневому) тегу. Он не соответствует внутреннему элементу a в <b><a/></b>, так как в этом случае он является потомком другого элемента.

/tag1/tag2

Совпадает с <tag2/> только в том случае, если он является потомком <tag1/>, и <tag1/> является корневым элементом.

Пример: /a/b соответствует элементу b в фрагменте XML <a><b/></a>, потому что он является потомком корневого элемента a. Он не соответствует <b><a/></b>, так как в этом случае b является корневым элементом (и, следовательно, не является потомком другого элемента). Выражение XPath также не соответствует <a><c><b/></c></a>; здесь b является потомком a, но не является потомком a.

Данный конструкт можно расширить до трех или более элементов. Например, выражение XPath /a/b/c соответствует элементу c во фрагменте <a><b><c/></b></a>.

//tag

Совпадает с любой инстанцией <tag>.

Пример: //a соответствует элементу a в любом из следующих фрагментов: <a><b><c/></b></a>; <c><a><b/></a></b>; <c><b><a/></b></c>.

// может быть объединен с /. Например, //a/b соответствует элементу b в любом из фрагментов <a><b/></a> или <c><a><b/></a></c>.

mysql> SET @xml = '<a><b><c>w</c><b>x</b><d>y</d>z</b></a>';
Query OK, 0 rows affected (0.00 sec)

mysql> SELECT @xml;
+-----------------------------------------+
| @xml                                    |
+-----------------------------------------+
| <a><b><c>w</c><b>x</b><d>y</d>z</b></a> |
+-----------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT ExtractValue(@xml, '//b[1]');
+------------------------------+
| ExtractValue(@xml, '//b[1]') |
+------------------------------+
| x z                          |
+------------------------------+
1 row in set (0.00 sec)

mysql> SELECT ExtractValue(@xml, '//b[2]');
+------------------------------+
| ExtractValue(@xml, '//b[2]') |
+------------------------------+
|                              |
+------------------------------+
1 row in set (0.01 sec)

mysql> SELECT ExtractValue(@xml, '/descendant-or-self::*/b[1]');
+---------------------------------------------------+
| ExtractValue(@xml, '/descendant-or-self::*/b[1]') |
+---------------------------------------------------+
| x z                                               |
+---------------------------------------------------+
1 row in set (0.06 sec)

mysql> SELECT ExtractValue(@xml, '/descendant-or-self::*/b[2]');
+---------------------------------------------------+
| ExtractValue(@xml, '/descendant-or-self::*/b[2]') |
+---------------------------------------------------+
|                                                   |
+---------------------------------------------------+
1 row in set (0.00 sec)


mysql> SELECT ExtractValue(@xml, '/descendant-or-self::b[1]');
+-------------------------------------------------+
| ExtractValue(@xml, '/descendant-or-self::b[1]') |
+-------------------------------------------------+
| z                                               |
+-------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT ExtractValue(@xml, '/descendant-or-self::b[2]');
+-------------------------------------------------+
| ExtractValue(@xml, '/descendant-or-self::b[2]') |
+-------------------------------------------------+
| x                                               |
+-------------------------------------------------+
1 row in set (0.00 sec)

Оператор * действует как «подстановочный символ», который соответствует любому элементу. Например, выражение /*/b соответствует элементу b в любом из следующих фрагментов XML: <a><b/></a> или <c><b/></c>. Однако выражение не соответствует фрагменту <b><a/></b>, так как b должен быть потомком некоторого другого элемента. Подстановочный символ может быть использован в любом месте: выражение /*/b/* соответствует любому потомку элемента b, который сам по себе не является корневым элементом.

Вы можете сопоставить любой из нескольких локеров, используя оператор | (UNION). Например, выражение //b|//c соответствует всем элементам b и c в целевом XML.

Также можно сопоставить элемент на основе значения одного или нескольких его атрибутов. Это делается с использованием синтаксиса tag[@attribute="value"]. Например, выражение //b[@id="idB"] соответствует второму элементу b во фрагменте <a><b id="idA"/><c/><b id="idB"/></a>. Чтобы сопоставить любой элемент, имеющий attribute="value", используйте выражение XPath //*[attribute="value"].

Для фильтрации нескольких значений атрибутов просто используйте несколько условий сравнения атрибутов последовательно. Например, выражение //b[@c="x"][@d="y"] соответствует элементу <b c="x" d="y"/>, встречающемуся где угодно в заданном фрагменте XML.

Чтобы найти элементы, для которых один и тот же атрибут соответствует одному из нескольких значений, можно использовать несколько локеров, соединённых оператором |. Например, чтобы сопоставить все элементы b, чьи атрибуты c имеют одно из значений 23 или 17, используйте выражение //b[@c="23"]|//b[@c="17"]. Для этой цели также можно использовать логический оператор or: //b[@c="23" or @c="17"].

Сравнение наборов узлов (например, '/a/b[@c=@d]') не поддерживается.

Все стандартные операторы сравнения XPath поддерживаются. (Ошибка #22823)

Выражения относительных локеров разрешаются в контексте корневого узла. Например, рассмотрите следующее запрос и результат:

mysql> SELECT ExtractValue(
    ->   '<a><b c="1">X</b><b c="2">Y</b></a>',
    ->    'a/b'
    -> ) AS result;
+--------+
| result |
+--------+
| X Y    |
+--------+
1 row in set (0.03 sec)

В этом случае локатор a/b разрешается в /a/b.

Относительные локеры также поддерживаются внутри предикатов. В следующем примере d[../@c="1"] разрешается как /a/b[@c="1"]/d:

mysql> SELECT ExtractValue(
    ->      '<a>
    ->        <b c="1"><d>X</d></b>
    ->        <b c="2"><d>X</d></b>
    ->      </a>',
    ->      'a/b/d[../@c="1"]')
    -> AS result;
+--------+
| result |
+--------+
| X      |
+--------+
1 row in set (0.00 sec)

Локеры, префиксные выражениями, которые вычисляются как скалярные значения (включая ссылки на переменные, литералы, числа и вызовы скалярных функций), не допускаются и приводят к ошибке.

Оператор :: не поддерживается в сочетании с типами узлов, такими как следующие:

Однако тесты имени (такие как axis::name и axis::*) поддерживаются, как показано в этих примерах:

mysql> SELECT ExtractValue('<a><b>x</b><c>y</c></a>','/a/child::b');
+-------------------------------------------------------+
| ExtractValue('<a><b>x</b><c>y</c></a>','/a/child::b') |
+-------------------------------------------------------+
| x                                                     |
+-------------------------------------------------------+
1 row in set (0.02 sec)

mysql> SELECT ExtractValue('<a><b>x</b><c>y</c></a>','/a/child::*');
+-------------------------------------------------------+
| ExtractValue('<a><b>x</b><c>y</c></a>','/a/child::*') |
+-------------------------------------------------------+
| x y                                                   |
+-------------------------------------------------------+
1 row in set (0.01 sec)

«Вверх-вниз» навигация не поддерживается в случаях, когда путь приведёт «выше» корневого элемента. То есть, нельзя использовать выражения, которые соответствуют потомкам предков данного элемента, где один или несколько предков текущего элемента также являются предками корневого элемента (см. ошибку #16321).

Следующие функции XPath не поддерживаются или имеют известные проблемы, как указано:

Никогда не принимайте непроверенные данные от пользователей в своем приложении.

Проверяйте тип всех данных, отправленных пользователем; отклоняйте или преобразуйте данные неправильного типа.

Проверяйте числовые данные на значения вне диапазона; обрезайте, округляйте или отклоняйте значения, выходящие за пределы диапазона. Проверяйте строки на наличие запрещенных символов и либо удаляйте их, либо отклоняйте входные данные, содержащие их.

Не выводите явных сообщений об ошибках, которые могут предоставить неавторизованному пользователю подсказки, которые могут быть использованы для компрометации системы; вместо этого записывайте их в файл или таблицу базы данных.

Всегда проверяйте выходные данные на тип и допустимые значения.

Никогда не разрешайте неавторизованным пользователям просматривать сообщения об ошибках, которые могут предоставить информацию об приложении, которое можно использовать для его взлома.