Переменные пользователя (слабая проверка). Переменные с синтаксисом $@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()') дают одинаковый результат.

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

Если для выражения не найдено соответствующего текстового узла (включая неявный /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()), учитывая согласование согласованности их аргументов; см. Раздел 10.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-фрагмент. Все три аргумента должны быть строками.

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 не поддерживаются или имеют известные проблемы, как указано:

Следующие оси не поддерживаются:

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

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

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

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

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

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