Алексей Валиков - Технология XSLT

Ниже приведена синтаксическая конструкция данной функции:

node-set key( string , object )

Итак, элементы xsl:keyнашего преобразования определили множество троек ( node , name , value ). Функция key( key-name , key-value )выбирает все узлы x такие, что значение их ключа с именем key-name (первым аргументом функции) равно key-value (второму аргументу функции).

Значением выражения key('src', 'a')будет множество элементов itemтаких, что значение их ключа "src"будет равно "а". Попросту говоря, это будет множество объектов источника "а".

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

Но не следует забывать, что язык XSLT — довольно нетрадиционный язык и с точки зрения синтаксиса, и с точки зрения модели данных. Как следствие, ключи в нем имеют довольно много скрытых нюансов, которые очень полезно знать и понимать. Мы попытаемся как можно более полно раскрыть все эти особенности.

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

атрибут useпоказывает, что значением ключа srcэлемента itemбудет значение атрибута source. Но что можно сказать о следующем определении:

Очевидно, это уже гораздо более сложный, но, тем не менее, вполне реальный случай, не вписывающийся в определения, которые давались до сих пор. Мы говорили лишь о том, что множество ключей определяется элементами xsl:keyпреобразования, но как именно оно определяется — оставалось доселе загадкой. Восполним этот пробел, дав строгое определение множеству ключей.

Узел xобладает ключом с именем уи строковым значением zтогда и только тогда, когда в преобразовании существует элемент xsl:keyтакой, что одновременно выполняются все нижеперечисленные условия:

□ узел xсоответствует паттерну, указанному в его атрибуте match;

□ значение его атрибута nameравно имени y;

□ результат uвычисления выражения, указанного в значении атрибута useв контексте текущего множества, состоящего из единственного узла x, удовлетворяет одному из следующих условий:

• uявляется множеством узлов и zравно одному из их строковых значений;

• uне является множеством узлов и zравно его строковому значению.

Без сомнения, определение не из простых. Но как бы мы действовали, если бы физически создавали в памяти множество ключей? Ниже представлен один из возможных алгоритмов:

□ для каждого элемента xsl:keyнайти множество узлов документа, удовлетворяющих его паттерну match(множество X);

□ для каждого из найденных узлов ( x∈ X) вычислить значение выражения атрибута use(значение u(x));

□ если u(x)является множеством узлов (назовем его U х), то для каждого u xi∈ U хсоздать ключ (x, n, string(u xi)), где n— имя ключа (значение атрибута nameэлемента xsl:key);

□ если u(x)является объектом другого типа (назовем его u x), создать ключ (x, n, string(u x)).

Найдем множество ключей, создаваемое определением

Имена всех ключей будут одинаковы и равны "src". Множество xузлов, удовлетворяющих паттерну item, будет содержать все элементы itemобрабатываемого документа. Значением выражения, заданного в атрибуте use, будет множество всех узлов атрибутов каждого из элементов item. Таким образом, множество узлов будет иметь следующий вид:

(< item name="А" .../>, 'src', 'a')

(< item name="А" .../>, 'src', 'A')

(< item name="В" .../>, 'src', 'b')

(< item name="В" .../>, 'src', 'В')

(< item name="С" .../>, 'src', 'а')

(< item name="С" .../>, 'src', 'С')

(< item name="D" .../>, 'src', 'с')

(< item name="D" .../>, 'src', 'D')

...

(< item name="H" .../>, 'src', 'a')

(< item name="H" .../>, 'src', 'H')

В итоге функция key('src', 'a')будет возвращать объекты с именами A, Cи H, а функция key('src', 'A')— единственный объект с именем A(поскольку ни у какого другого элемента itemнет атрибута со значением "A").

Необходимо сделать следующее замечание: совершенно необязательно, чтобы процессор действительно физически создавал в памяти множества ключей. Это множество определяется чисто логически — чтобы было ясно, что же все-таки будет возвращать функция key. Процессоры могут вычислять значения ключей и искать узлы в документе и во время выполнения, не генерируя ничего заранее. Но большинство процессоров, как правило, все же создают в памяти определенные структуры для манипуляций с ключами. Это могут быть хэш-таблицы, списки, простые массивы или более сложные нелинейные структуры, упрощающие поиск, — важно другое. Важно то, что имея явное определение ключа в xsl:key, процессор может производить такую оптимизацию.

В случае, когда к узлам в преобразовании нужно обращаться по значениям различных свойств, можно определить несколько ключей — каждый со своим именем. Например, если мы хотим в одном случае обращаться к объектам, принадлежащим одному источнику, а во втором — к объектам с определенными именами, мы можем определить в документе два ключа — один с именем src, второй — с именем name:

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

(< item name="А" .../>, 'src', 'а')

(< item name="А" .../>, 'name', 'А')

(< item name="В" .../>, 'src', 'b')

(< item name="В" .../>, 'name', 'В')

(< item name="C" .../>, 'src', 'a')

(< item name="C" .../>, 'name', 'С')

(< item name="D" .../>, 'src', 'с')

(< item name="D" .../>, 'name', 'D')

...

(< item name="H" .../>, 'src', 'a')

(< item name="H" .../>, 'name', 'H')

В этом случае функция key('src', 'а')возвратит объекты с именами A, Cи H, а функция key('name', 'а')— объект с именем А.

Имя ключа является расширенным именем. Оно может иметь объявленный префикс пространства имен, например

name="data:src"

match="item"

use="@source"

xmlns:data="urn:user-data"/>