Array

Шаблон Array

Минимальный шаблон

<Array>
    <!-- Источник массива -->
    <Source></Source>
    <!-- Получение индекса первого элемента. -->
    <Filter>
        <Not>
            <And>
                <Or>
                    <Filter Type="Equal">
                        <!-- или Field (для DC) или Index (для массивов)-->
                        <Field></Field>
                        <Index></Index>
                        <DataType Type=""></DataType>
                        <Value></Value>
                    </Filter>
                </Or>
            </And>
        </Not>
    </Filter>
    <!-- Уникальные элементы в массиве. Если теги On не указаны, используется первый элемент -->
    <Distinct>
      <On Index="" />
    </Distinct>
    <!-- Сортировка. Если теги By не указаны, используется первый элемент и сортируется по возрастанию  -->
    <Order>
      <By Index="" Type="Asc" />
      <By Index="" Type="Desc" />
    </Order>
    <!-- Создать новый массив на основе существующего. Если Items.Count == 1 то возвращает одномерный массив -->
    <Select>
        <Items>
            <!-- Элемент массива -->
            <Item Type="Index"></Item>
            <!-- Выбор из словаря -->
            <Item Type="Field"><!-- название элемента словаря --></Item>
            <!-- Скалярное значение -->
            <Item Type="Value"></Item>
            <!-- Порядковый номер элемента массива -->
            <Item Type="Number" Start="0"></Item>
            <!-- Форматирование значений -->
            <Item Type="Format"></Item>
            <!-- Работа с вложенными массивами -->
            <Item Type="Action">
                <Index><!-- индекс элемента массива --></Index>
                <Actions><!-- цепочка действий. Доступны все действия над массивами--></Actions>
            </Item>
            <!-- Расчет выражения -->
            <Item Type="Expression">
                <!-- В выражении могут использоваться элементы массива ([0]) и дополнительные значения ({0}).-->
                <!-- Дополнительно можно добавить переменную Index -->
                <Expression>{0} > 0</Expression>
                <Items>
                    <!-- Дополнительные значения -->
                    <Item></Item>
                </Items>
            </Item>
            <!-- Подстановка значений -->
            <Item>
                <Index><!-- индекс элемента массива --></Index>
                <Value><!-- таблица значений --></Value>
            </Item>
        </Items>
    </Select>    
</Array>

Полный шаблон Array

<Array>
    <!-- Источник массива -->
    <Source></Source>
    <!-- Добавить в массив значение и вернуть новый массив -->
    <Add></Add>
    <!-- Возвращает элемент массива. Для одномерного массива возвращается скалярное значение. Для многомерного - одномерный массив значений -->
    <ElementAt>
        <Index><!-- value --></Index>
    </ElementAt>
    <!-- Удаление элементов из массива -->
    <Remove>
        <!-- Для удаления одного элемента -->
        <Index></Index>
        <!-- Для удаления нескольких элементов -->
        <Indices>
            <Index></Index>
        </Indices>
        <Structure Type="List">
            <Item></Item>
            <Item></Item>
            <Item></Item>
        </Structure>
    </Remove>
    <!-- Обновить элемент по индексу -->
    <Update>
        <Index></Index>
        <!-- Для одномерного массива -->
        <Value></Value>
        <!-- Для многомерных массивов -->
        <Value>
            <Row>
                <Item></Item>
            </Row>
        </Value>
    </Update>
    <!-- Создать новый массив на основе существующего. Операция Map. Если Items.Count == 1 то возвращает одномерный массив -->
    <Select>
        <Items>
            <Item Type="Expression">
                <!-- В выражении могут использоваться элементы массива ([0]) и дополнительные значения ({0}).-->
                <!-- Дополнительно можно добавить переменную Index -->
                <Expression>{0} > 0</Expression>
                <Items>
                    <Item></Item>
                <Items>
            </Item>
            <!-- Скалярное значение -->
            <Item Type="Value"></Item>
            <!-- Элемент массива -->
            <Item Type="Index"></Item>
            <!-- Порядковый номер элемента массива -->
            <Item Type="Number" Start="0"></Item>
            <!-- Форматирование значений -->
            <Item Type="Format"></Item>
            <!-- Работа с вложенными массивами -->
            <Item Type="Action">
                <Index><!-- индекс элемента массива --></Index>
                <Actions><!-- цепочка действий. Доступны все действия над массивами--></Actions>
            </Item>
            <!-- Подстановка значений -->
            <Item>
                <Index><!-- индекс элемента массива --></Index>
                <Value><!-- таблица значений --></Value>
            </Item>
            <!-- Выбор из словаря -->
            <Item Type="Field"><!-- название элемента словаря --></Item>
        </Items>
    </Select>
    <!-- Агрегация значений. Операция Reduce/Fold. Для одного элемента - скаляр. Для нескольких элементов одномерный массив значений -->
    <Aggregate>
        <Items>
            <Item>
                <!-- Начальное значение -->
                <Result>0</Result>
                <!-- В выражении могут использоваться элементы массива ([0]) и дополнительные значения ({0}).-->
                <!-- Дополнительно можно добавить переменную Index -->
                <!-- Полученный результат сохраняется в Result и вычисляется значение для следующей строки -->
                <!-- Пример расчёта суммы -->
                <Expression>{Result} + {0}</Expression>
                <Items>
                    <Item></Item>
                <Items>
            </Item>
        </Items>
    </Aggregate>
    <!-- Максимальный элемент. Только для одномерных массивов -->
    <Max Type="" />
    <!-- Минимальный элемент. Только для одномерных массивов -->
    <Min Type="" />
    <!-- Получение индекса первого элемента. -->
    <Filter>
        <Not>
            <And>
                <Or>
                    <Filter Type="Equal">
                        <!-- или Field (для DC) или Index (для массивов)-->
                        <Field></Field>
                        <Index></Index>
                        <DataType Type=""></DataType>
                        <Value></Value>
                    </Filter>
                </Or>
            </And>
        </Not>
    </Filter>
    <!-- Первый элемент -->
    <First />
    <!-- Последний элемент -->
    <Last />
    <!-- Форматирует текущий массив в строку -->
    <!-- Если элемент массива Dictionary<string, object>, то доступны поля по {Key}. Для одномерных массивов {0}, {1} -->
    <Format></Format>
    <!-- Объединяет текущий массив в строку с разделителем -->
    <StringJoin Separator="<!-- разделитель элементов -->" LineSeparator="<!-- разделитель строк -->" />
    <!-- Пропустить N строк -->
    <Skip></Skip>
    <!-- Взять из массива N строк -->
    <Take></Take>
    <!-- Количество элементов в массиве -->
    <Count />
    <!-- Уникальные элементы в массиве. Если теги On не указаны, используется первый элемент -->
    <Distinct>
      <On Index="" />
    </Distinct>
    <!-- Индекс элемента (только для одномерных массивов) -->
    <!-- Содержимое тега аналогично тегу Filter -->
    <IndexOf></IndexOf>
    <!-- Преобразовать одномерный массив в многомерный. Для многомерных ничего не делается -->
    <ToTable />
    <!-- Преобразование значение в одномерный массив -->
    <ToArray />
    <!-- Преобразование двухмерного массива в массив словарей -->
    <ToDictionary>
        <!-- Атрибут Name: название элемента словаря -->
        <!-- Атрибут Index: индекс элемента массива, который будет записан в словарь под именем указанным в атрибуте Name -->
        <Key Name="" Index=""/>
    </ToDictionary>
    <!-- Сортировка (только для одномерных массивов) -->
    <Sort />
    <!-- Сортировка. Если теги By не указаны, используется первый элемент и сортируется по возрастанию  -->
    <Order>
      <By Index="" Type="Asc" />
      <By Index="" Type="Desc" />
    </Order>
    <!-- Объединение массивов -->
    <Union><!-- массив --></Union>
    <!-- Для ConvertDC. Для массива Dictionary<string, object> формирует массив из значений словаря по указанному ключу -->
    <Field><!-- field name --></Field>
    <!-- Преобразовать массив массивов ([[1,2,3,...], [4,5,...]]) в одномерный ([1,2,3,...,4,5,...]) -->
    <SelectMany></SelectMany>
    
    <!--Объединения массивов по ключам-->
	<!-- Inner - текущий массив, Outer - массив с которыем будет соединён текущий -->
    <Join>
      <OuterArray><!-- массив с которым будет текущий соединён--></OuterArray>
	  <!--Ключи по которым будуд соединяться массивы-->
      <Keys>
		<!-- Атрибут Index: индекс элемента массива, который будет использоваться в качестве составного ключа -->
		<!-- Количество тегов Inner и Outer должно совпадать -->
        <Inner Index="" />
        <Inner Index="" />
        <Outer Index="" />
        <Outer Index="" />
      </Keys>
	  <!-- Результат объединения -->
      <Result>
	    <!-- Атрибут Index: индекс элемента массива, который будет добавлен в результирующую строку. Если тег Inner, то значение будет выбрано из исходного массива. Если Outer, то из массива из тега OuterArray -->
        <Inner Index="" />
        <Inner Index="" />
        <Outer Index="" />
        <Outer Index="" />
      </Result>
    </Join>
	<!-- Левостороннее соединение -->
    <LeftJoin>
      <OuterArray></OuterArray>
      <Keys>
        <Inner Index="" />
        <Inner Index="" />
        <Outer Index="" />
        <Outer Index="" />
      </Keys>
      <Result>
        <Inner Index="" />
        <Inner Index="" />
        <Outer Index="" />
        <Outer Index="" />
      </Result>
    </LeftJoin>
	<!-- Правостороннее соединение -->
    <RightJoin>
      <OuterArray></OuterArray>
      <Keys>
        <Inner Index="" />
        <Inner Index="" />
        <Outer Index="" />
        <Outer Index="" />
      </Keys>
      <Result>
        <Inner Index="" />
        <Inner Index="" />
        <Outer Index="" />
        <Outer Index="" />
      </Result>
    </RightJoin>
	<!-- Полное соединение -->
    <FullJoin>
      <OuterArray></OuterArray>
      <Keys>
        <Inner Index="" />
        <Inner Index="" />
        <Outer Index="" />
        <Outer Index="" />
      </Keys>
      <Result>
        <Inner Index="" />
        <Inner Index="" />
        <Outer Index="" />
        <Outer Index="" />
      </Result>
    </FullJoin>
    
</Array>

Описание Array

Значение, которое будет передано в команду при выполнении.

<Array>
  <Source></Source>
  <Operation1></Operation1>
  <Operation2></Operation2>
</Array>

В тэге <Source> указывается любое универсальное значение, с которым выполняются операции указанные после тэга <Source> - Operation1, Operation2. Операций может быть неограниченное количество. При этом операции будут выполняться последовательно в порядке объявления: для первой операции (Operation1) используется значение из тэга <Source>, для последующих операций - результат предыдущей операции.

Все операции можно разделить на группы:

• Изменение

• Агрегация

• Поиск

• Соединение

• Выборка из массива

• Преобразование

• Сортировка

Изменение

Add

Добавляет элемент или элементы в массив.

<Add><!-- элементы для добавления --></Add>

При добавлении элементов используются следующие правила:

• Матрица добавляется в Матрицу Строки из матрицы, указанной в тэге <Value>, добавляются в конец матрицы из тэга <Source>.

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Source>
  <Add>
    <Structure Type="Table">
      <Row>
        <Item>3</Item>
        <Item>Text 3</Item>
      </Row>
      <Row>
        <Item>4</Item>
        <Item>Text 4</Item>
      </Row>
    </Structure>
  </Add>
</Array>

Результат:

+-----+----------+
|  1  |  Text 1  |
|  2  |  Text 2  |
|  3  |  Text 3  |
|  4  |  Text 4  |
+-----+----------+

• Массив добавляется в Матрицу В массив из тэга <Value> добавляются пустые элементы, чтобы длина массива соответствовала наибольшей длине строки матрицы, указанной в тэге <Source>, и полученный массив добавляются в конец матрицы.

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>True</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>False</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Source>
  <Add>
    <Structure Type="List">
      <Item>3</Item>
      <Item>False</Item>
    </Structure>
  </Add>
</Array>

Результат:

+-----+---------+----------+
|  1  |  True   |  Text 1  |
|  2  |  False  |  Text 2  |
|  3  |  False  |          |
+-----+---------+----------+

• Скаляр добавляется в Матрицу Скаляр из тэга <Value> преобразуется в массив с длиной соответствующей наибольшей длине строки матрицы, указанной в тэге <Source>, и полученный массив добавляются в конец матрицы.

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>True</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>False</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Source>
  <Add>3</Add>
</Array>

Результат:

+-----+---------+----------+
|  1  |  True   |  Text 1  |
|  2  |  False  |  Text 2  |
|  3  |         |          |
+-----+---------+----------+

• Матрица добавляется в Массив Первый столбец матрицы, указанной в тэге <Value>, преобразуется в массив и добавляется в конец массива из тэга <Source>.

Пример

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
    </Structure>
  </Source>
  <Add>
    <Structure Type="Table">
      <Row>
        <Item>3</Item>
        <Item>Text 3</Item>
      </Row>
      <Row>
        <Item>4</Item>
        <Item>Text 4</Item>
      </Row>
    </Structure>
  </Add>
</Array>

Результат:

+-----+-----+-----+-----+
|  1  |  2  |  3  |  4  |
+-----+-----+-----+-----+

• Массив добавляется в Массив Массив из тэга <Value> добавляется в конец массива, указанного в тэге <Source>.

Пример

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
    </Structure>
  </Source>
  <Add>
    <Structure Type="List">
      <Item>3</Item>
      <Item>4</Item>
    </Structure>
  </Add>
</Array>

Результат:

+-----+-----+-----+-----+
|  1  |  2  |  3  |  4  |
+-----+-----+-----+-----+

• Скаляр добавляется в Массив Скаляр из тэга <Value> добавляется в конец массива, указанного в тэге <Source>.

Пример

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
    </Structure>
  </Source>
  <Add>3</Add>
</Array>

Результат:

+-----+-----+-----+
|  1  |  2  |  3  |
+-----+-----+-----+

• Во всех случаях, когда в качестве значения тэга <Source> указан скаляр, будет генерироваться ошибка TypeMismatch.

InsertAt

Добавляет элемент или элементы в массив в указанную позицию.

<InsertAt>
  <Index><!-- индекс элемента --></Index>
  <Value><!-- элементы для добавления --></Value>
</InsertAt>

При добавлении элементов используются следующие правила:

• Матрица добавляется в Матрицу Строки из матрицы, указанной в тэге <Value>, добавляются в конец матрицы из тэга <Source> или в позицию с индексом из тэга <Index>.

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Source>
  <InsertAt>
    <Index>1</Index>
    <Value>
      <Structure Type="Table">
        <Row>
          <Item>3</Item>
          <Item>Text 3</Item>
        </Row>
        <Row>
          <Item>4</Item>
          <Item>Text 4</Item>
        </Row>
      </Structure>
    </Value>
  </InsertAt>
</Array>

Результат:

+-----+----------+
|  1  |  Text 1  |
|  3  |  Text 3  |
|  4  |  Text 4  |
|  2  |  Text 2  |
+-----+----------+

• Массив добавляется в Матрицу В массив из тэга <Value> добавляются пустые элементы, чтобы длина массива соответствовала наибольшей длине строки матрицы, указанной в тэге <Source>, и полученный массив добавляются в конец матрицы или в позицию с индексом из тэга <Index>.

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>True</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>False</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Source>
  <InsertAt>
    <Index>1</Index>
    <Value>
      <Structure Type="List">
        <Item>3</Item>
        <Item>False</Item>
      </Structure>
    </Value>
  </InsertAt>
</Array>

Результат:

+-----+---------+----------+
|  1  |  True   |  Text 1  |
|  3  |  False  |          |
|  2  |  False  |  Text 2  |
+-----+---------+----------+

• Скаляр добавляется в Матрицу Скаляр из тэга <Value> преобразуется в массив с длиной соответствующей наибольшей длине строки матрицы, указанной в тэге <Source>, и полученный массив добавляются в конец матрицы или в позицию с индексом из тэга <Index>.

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>True</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>False</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Source>
  <InsertAt>
    <Index>0</Index>
    <Value>3</Value>
  </InsertAt>
</Array>

Результат:

+-----+---------+----------+
|  3  |         |          |
|  1  |  True   |  Text 1  |
|  2  |  False  |  Text 2  |
+-----+---------+----------+

• Матрица добавляется в Массив Первый столбец матрицы, указанной в тэге <Value>, преобразуется в массив и добавляется в конец массива из тэга <Source> или в позицию с индексом из тэга <Index>.

Пример

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
    </Structure>
  </Source>
  <InsertAt>
    <Index>1</Index>
    <Value>
      <Structure Type="Table">
        <Row>
          <Item>3</Item>
          <Item>Text 3</Item>
        </Row>
        <Row>
          <Item>4</Item>
          <Item>Text 4</Item>
        </Row>
      </Structure>
    </Value>
  </InsertAt>
</Array>

Результат:

+-----+-----+-----+-----+
|  1  |  3  |  4  |  2  |
+-----+-----+-----+-----+

• Массив добавляется в Массив Массив из тэга <Value> добавляется в конец массива, указанного в тэге <Source> или в позицию с индексом из тэга <Index>.

Пример

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
    </Structure>
  </Source>
  <InsertAt>
    <Index>0</Index>
    <Value>
      <Structure Type="List">
        <Item>3</Item>
        <Item>4</Item>
      </Structure>
    </Value>
  </InsertAt>
</Array>

Результат:

+-----+-----+-----+-----+
|  3  |  4  |  1  |  2  |
+-----+-----+-----+-----+

• Скаляр добавляется в Массив Скаляр из тэга <Value> добавляется в конец массива, указанного в тэге <Source> или в позицию с индексом из тэга <Index>.

Пример

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
    </Structure>
  </Source>
  <InsertAt>
    <Index>0</Index>
    <Value>3</Value>
  </InsertAt>
</Array>

Результат:

+-----+-----+-----+
|  3  |  1  |  2  |
+-----+-----+-----+

• Во всех случаях, когда в качестве значения тэга <Source> указан скаляр, будет генерироваться ошибка TypeMismatch.

Update

Обновляет элемент в массиве/матрице в указанной позиции.

<Update>
  <Index><!-- индекс элемента --></Index>
  <Value><!-- элемент для обновления --></Value>
</Update>

При обновлении элементов используются следующие правила:

• Массив добавляется в Матрицу В массив из тэга <Value> добавляются пустые элементы, чтобы длина массива соответствовала наибольшей длине строки матрицы, указанной в тэге <Source>, и полученный массив записывается в элемент с индексом <Index>.

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>True</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>False</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Source>
  <Update>
    <Index>0</Index>
    <Value>
      <Structure Type="List">
        <Item>3</Item>
        <Item>False</Item>
      </Structure>
    </Value>
  </Update>
</Array>

Результат:

+-----+---------+----------+
|  3  |  False  |          |
|  2  |  False  |  Text 2  |
+-----+---------+----------+

• Скаляр добавляется в Матрицу Скаляр из тэга <Value> преобразуется в массив с длиной соответствующей наибольшей длине строки матрицы, указанной в тэге <Source>, и полученный массив записывается в элемент с индексом <Index>.

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>True</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>False</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Source>
  <Update>
    <Index>0</Index>
    <Value>3</Value>
  </Update>
</Array>

Результат:

+-----+---------+----------+
|  3  |         |          |
|  2  |  False  |  Text 2  |
+-----+---------+----------+

• Матрица добавляется в Массив Берет первый элемент первой строки матрицы, указанной в тэге <Value>, и записывается в элемент с индексом <Index> массива из тэга <Source>.

Пример

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
    </Structure>
  </Source>
  <Update>
    <Index>0</Index>
    <Value>
      <Structure Type="Table">
        <Row>
          <Item>3</Item>
          <Item>Text 3</Item>
        </Row>
        <Row>
          <Item>4</Item>
          <Item>Text 4</Item>
        </Row>
      </Structure>
    </Value>
  </Update>
</Array>

Результат:

+-----+-----+
|  3  |  2  |
+-----+-----+

• Массив добавляется в Массив Берется первый элемент массива из тэга <Value> и записывается в элемент с индексом <Index> массива, указанном в тэге <Source>.

Пример

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
    </Structure>
  </Source>
  <Update>
    <Index>0</Index>
    <Value>
      <Structure Type="List">
        <Item>3</Item>
        <Item>4</Item>
      </Structure>
    </Value>
  </Update>
</Array>

Результат:

+-----+-----+
|  3  |  2  |
+-----+-----+

• Скаляр добавляется в Массив Скаляр из тэга <Value> записывается в элемент с индексом <Index> массива, указанного в тэге <Source>.

Пример

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
    </Structure>
  </Source>
  <Update>
    <Index>0</Index>
    <Value>3</Value>
  </Update>
</Array>

Результат:

+-----+-----+
|  3  |  2  |
+-----+-----+

• Во всех случаях, когда в качестве значения тэга <Source> указан скаляр, будет генерироваться ошибка TypeMismatch.

Remove

Удаляет элемент(ы) по индексу или индексам.

<Remove><!-- индекс или массив индексов --></Remove>

Если в качестве значения тэга <Source> указан скаляр, то будет генерироваться ошибка TypeMismatch.

Пример 1. Удаление элемента из матрицы

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
      <Row>
        <Item>3</Item>
        <Item>Text 3</Item>
      </Row>
    </Structure>
  </Source>
  <Remove>1</Remove>
</Array>

Результат:

+-----+----------+
|  1  |  Text 1  |
|  3  |  Text 3  |
+-----+----------+

Пример 2. Удаление элемента из массива

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
      <Item>3</Item>
    </Structure>
  </Source>
  <Remove>1</Remove>
</Array>

Результат:

+-----+-----+
|  1  |  3  |
+-----+-----+

Пример 3. Удаление элементов из матрицы

<<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
      <Row>
        <Item>3</Item>
        <Item>Text 3</Item>
      </Row>
      <Row>
        <Item>4</Item>
        <Item>Text 4</Item>
      </Row>
    </Structure>
  </Source>
  <Remove>
    <Structure Type="List">
      <Item>0</Item>
      <Item>2</Item>
    </Structure>
  </Remove>
</Array>

Результат:

+-----+----------+
|  2  |  Text 2  |
|  4  |  Text 4  |
+-----+----------+

Агрегация

Aggregate

Вычисляет значения по формулам.

<Aggregate>
  <Items>
    <Item>
      <Result><!-- Начальное значение --></Result>
      <Expression><!-- Выражение для расчёта--></Expression>	
      <Items>
         <!-- Дополнительные значение -->
        <Item></Item>
      <Items>
    </Item>
  </Items>
</Aggregate>

В выражении <Expression> могут использоваться элементы исходного массива (указываются в квадратных скобках []) или дополнительные значения, перечисленные в тэге <Items> (указываются в фигурных скобках {}). Также доступна переменная {Result}, в которой хранится значение, вычисленное для прошлого элемента.

Если элементов Item в Aggregate/Items несколько, то возвращается массив результатов агрегации. Если один, то скалярное значение.

Для вычисления выражений используется NCalc.

Если в качестве значения тэга <Source> указан скаляр, то будет генерироваться ошибка TypeMismatch.

Пример 1. Сумма и произведение всех элементов массива

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
      <Item>3</Item>
      <Item>4</Item>
    </Structure>
  </Source>
  <Aggregate>
    <Items>
      <Item>
        <Result>0</Result>
        <Expression>{Result} + [0]</Expression>
      </Item>
      <Item>
        <Result>1</Result>
        <Expression>{Result} * [0]</Expression>
      </Item>
    </Items>
  </Aggregate>
</Array>

Результат:

+------+------+
|  10  |  24  |
+------+------+

Пример 2. Сумма произведения элементов матрицы

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>65</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>69</Item>
      </Row>
    </Structure>
  </Source>
  <Aggregate>
    <Items>
      <Item>
        <Result>0</Result>
        <Expression>{Result} + [0] * [1]</Expression>
      </Item>
    </Items>
  </Aggregate>
</Array>

Результат:

203

Count

Считает количество элементов в массиве.

<Count />

Если в качестве значения тэга <Source> указан скаляр, то будет генерироваться ошибка TypeMismatch.

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Source>
  <Count />
</Array>

Результат:

2

Max

Находит максимальный элемент в массиве или в столбце матрицы.

<Max Type="" Index="" />

В атрибуте Type задаётся один из типов.

В необязательном атрибуте Index для матриц указывается индекс столбца, в котором будет происходить поиск максимального элемента. Если атрибут не указан, то используется значение 0.

Если в качестве значения тэга <Source> указан скаляр, то будет генерироваться ошибка TypeMismatch.

Пример 1. Максимальный элемент в третьем столбце матрицы

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
        <Item>45</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
        <Item>61</Item>
      </Row>
      <Row>
        <Item>3</Item>
        <Item>Text 3</Item>
        <Item>22</Item>
      </Row>
    </Structure>
  </Source>
  <Max Type="IntegerDataType" Index="2" />
</Array>

Результат:

61

Пример 2. Максимальный элемент массива

<Array>
  <Source>
    <Structure Type="List">
      <Item>7</Item>
      <Item>2</Item>
      <Item>10</Item>
      <Item>5</Item>
    </Structure>
  </Source>
  <Max Type="IntegerDataType" />
</Array>

Результат:

10

Min

Находит минимальный элемент в массиве или в столбце матрицы.

<Min Type="" Index="" />

В атрибуте Type задаётся один из типов.

В необязательном атрибуте Index для матриц указывается индекс столбца, в котором будет происходить поиск минимального элемента. Если атрибут не указан, то используется значение 0.

Если в качестве значения тэга <Source> указан скаляр, то будет генерироваться ошибка TypeMismatch.

Пример 1. Минимальный элемент в третьем столбце матрицы

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
        <Item>45</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
        <Item>61</Item>
      </Row>
      <Row>
        <Item>3</Item>
        <Item>Text 3</Item>
        <Item>22</Item>
      </Row>
    </Structure>
  </Source>
  <Min Type="IntegerDataType" Index="2" />
</Array>

Результат:

22

Пример 2. Минимальный элемент массива

<Array>
  <Source>
    <Structure Type="List">
      <Item>7</Item>
      <Item>2</Item>
      <Item>10</Item>
      <Item>5</Item>
    </Structure>
  </Source>
  <Min Type="IntegerDataType" />
</Array>

Результат:

2

Sum

Находит сумму элементов в массиве или в столбце матрицы.

<Sum Type="" Index="" />

В атрибуте Type задаётся один из типов.

В необязательном атрибуте Index для матриц указывается индекс столбца, для которого будет вычисляться сумма элементов. Если атрибут не указан, то используется значение 0.

Если в качестве значения тэга <Source> указан скаляр, то будет генерироваться ошибка TypeMismatch.

Пример 1. Сумма элементов в третьем столбце матрицы

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
        <Item>45</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
        <Item>61</Item>
      </Row>
      <Row>
        <Item>3</Item>
        <Item>Text 3</Item>
        <Item>22</Item>
      </Row>
    </Structure>
  </Source>
  <Sum Type="IntegerDataType" Index="2" />
</Array>

Результат:

128

Пример 2. Сумма элементов массива

<Array>
  <Source>
    <Structure Type="List">
      <Item>7</Item>
      <Item>2</Item>
      <Item>10</Item>
      <Item>5</Item>
    </Structure>
  </Source>
  <Sum Type="IntegerDataType" />
</Array>

Результат:

24

Поиск

IndexOf

Возвращает индекс первого элемента массива удовлетворяющего условию.

<!-- общий синтаксис для поиска -->
<IndexOf Type="">
  <Field Name="" />
  <!-- или -->
  <Index Value="" />
  <Value><!-- значение фильтра --></Value>
  <DataType Type="" />
</IndexOf>

В необязательном атрибуте Type тэга <IndexOf> указывается тип сравнения значений. По умолчанию используется фильтр Equal.

Тэг <Field> применяется для выборки из массива словарей. В атрибуте Name указывается название поля словаря, по которому будет происходить проверка условия.

Тэг <Index> применяется для выборки из одномерного массива или матрицы. Для матриц в атрибуте Value указывается индекс элемента строки, по которому будет проверка условия.

Тэг <DataType> задаёт тип элемента. По умолчанию используется тип StringDataType.

В зависимости от типа фильтра тэги <Value> или <DataType> могут отсутствовать. Например, в фильтрах IsNull, IsNotNull.

Типы сравнения значений

Equal	Сравнение значений на равенство
NotEqual	Сравнение значений на неравенство
Greater	Сравнение значений на "больше": элемент массива больше указанного значения
GreaterOrEqual	Сравнение значений на "больше или равно": элемент массива больше или равен указанному значению
Less	Сравнение значений на "меньше": элемент массива меньше указанного значения
LessOrEqual	Сравнение значений на "меньше или равно": элемент массива меньше или равен указанному значению
Contains	Сравнение значений на "содержит": элемент массива содержит указанное значение, при этом все значения преобразуется в строку
NotContains	Сравнение значений на "не содержит": элемент массива не содержит указанное значение, при этом все значения преобразуется в строку
In	Сравнение значений на "входит": элемент массива входит в указанный массив
NotIn	Сравнение значений на "не входит": элемент массива не входит в указанный массив
Overlap	Сравнение значений на "пересекается": массив из элемента исходного массива имеет общие элементы с указанным массивом
NotOverlap	Сравнение значений на "не пересекается": массив из элемента исходного массива не имеет общие элементы с указанным массивом
MatchSearch	Сравнение значений на "удовлетворяет поисковой строке". Поисковая строка может состоять из слов, разделенных пробелами и символами "+", "*" и "?": пробел означает "ИЛИ"; "+" означает "И"; "*" означает любое количество любых символов; "?" означает ровно один символ.
NotMatchSearch	Сравнение значений на "не удовлетворяет поисковой строке". Поисковая строка может состоять из слов, разделенных пробелами и символами "+", "*" и "?": пробел означает "ИЛИ"; "+" означает "И"; "*" означает любое количество любых символов; "?" означает ровно один символ.
ContainedIn	Сравнение значений на "входит": элемент массива входит в указанное значение, при этом все значения преобразуется в строку
NotContainedIn	Сравнение значений на "не входит": элемент массива не входит в указанное значение, при этом все значения преобразуется в строку
IsNull	Сравнение на Null
IsNotNull	Сравнение на "не Null"
Nested	Составной фильтр. Для соединения вложенных фильтров (<Filter>) доступны тэги <And>, <Or>, <Not>

Если в качестве значения тэга <Source> указан скаляр, то будет генерироваться ошибка TypeMismatch.

Пример 1. Индекс первого элемента массива, который больше 10

<Array>
  <Source>
    <Structure Type="List">
      <Item>-1</Item>
      <Item>1</Item>
      <Item>30</Item>
      <Item>5</Item>
      <Item>15</Item>
    </Structure>
  </Source>
  <IndexOf Type="Greater">
    <Value>10</Value>
    <DataType Type="IntegerDataType" />
  </IndexOf>
</Array>

Результат:

2

Пример 2. Индекс первого элемента массива, который больше 0 и меньше 20

<Array>
  <Source>
    <Structure Type="List">
      <Item>-1</Item>
      <Item>1</Item>
      <Item>30</Item>
      <Item>5</Item>
      <Item>15</Item>
    </Structure>
  </Source>
  <IndexOf Type="Nested">
    <And>
      <Filter Type="Greater">
        <Value>0</Value>
        <DataType Type="IntegerDataType" />
      </Filter>
      <Filter Type="Less">
        <Value>20</Value>
        <DataType Type="IntegerDataType" />
      </Filter>
    </And>
  </IndexOf>
</Array>

Результат:

1

Пример 3. Индекс первого элемента матрицы, где второй столбец меньше 0

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>2</Item>
        <Item>2</Item>
      </Row>
      <Row>
        <Item>3</Item>
        <Item>-1</Item>
      </Row>
      <Row>
        <Item>4</Item>
        <Item>15</Item>
      </Row>
      <Row>
        <Item>6</Item>
        <Item>-5</Item>
      </Row>
      <Row>
        <Item>7</Item>
        <Item>5</Item>
      </Row>
    </Structure>
  </Source>
  <IndexOf Type="Less">
    <Index Value="1" />
    <Value>0</Value>
    <DataType Type="IntegerDataType" />
  </IndexOf>
</Array>

Результат:

1

Пример 4. Индекс первого элемента матрицы, где первый столбец больше 4 и второй в диапазоне от -10 до 10

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>2</Item>
        <Item>2</Item>
      </Row>
      <Row>
        <Item>3</Item>
        <Item>-1</Item>
      </Row>
      <Row>
        <Item>4</Item>
        <Item>15</Item>
      </Row>
      <Row>
        <Item>6</Item>
        <Item>-5</Item>
      </Row>
      <Row>
        <Item>7</Item>
        <Item>5</Item>
      </Row>
    </Structure>
  </Source>
  <IndexOf Type="Nested">
    <And>
      <Filter Type="Greater">
        <Value>4</Value>
        <DataType Type="IntegerDataType" />
      </Filter>
      <Filter Type="Greater">
        <Index Value="1" />
        <Value>-10</Value>
        <DataType Type="IntegerDataType" />
      </Filter>
      <Filter Type="Less">
        <Index Value="1" />
        <Value>10</Value>
        <DataType Type="IntegerDataType" />
      </Filter>
    </And>
  </IndexOf>
</Array>

Результат:

3

Filter

Возвращает элементы массива, удовлетворяющие условию.

<!-- общий синтаксис для фильтров -->
<Filter Type="">
  <Field Name="" />
  <!-- или -->
  <Index Value="" />
  <Value><!-- значение фильтра --></Value>
  <DataType Type="" />
</Filter>

В необязательном атрибуте Type тэга <Filter> указывается тип фильтра. По умолчанию используется фильтр Equal.

Тэг <Field> применяется для выборки из массива словарей. В атрибуте Name указывается название поля словаря, по которому будет происходить проверка условия.

Тэг <Index> применяется для выборки из одномерного массива или матрицы. Для матриц в атрибуте Value указывается индекс элемента строки, по которому будет проверка условия.

Тэг <DataType> задаёт тип элемента. По умолчанию используется тип StringDataType.

В зависимости от типа фильтра тэги <Value> или <DataType> могут отсутствовать. Например, в фильтрах IsNull, IsNotNull.

Типы фильтров

Equal	Сравнение значений на равенство
NotEqual	Сравнение значений на неравенство
Greater	Сравнение значений на "больше": элемент массива больше указанного значения
GreaterOrEqual	Сравнение значений на "больше или равно": элемент массива больше или равен указанному значению
Less	Сравнение значений на "меньше": элемент массива меньше указанного значения
LessOrEqual	Сравнение значений на "меньше или равно": элемент массива меньше или равен указанному значению
Contains	Сравнение значений на "содержит": элемент массива содержит указанное значение, при этом все значения преобразуется в строку
NotContains	Сравнение значений на "не содержит": элемент массива не содержит указанное значение, при этом все значения преобразуется в строку
In	Сравнение значений на "входит": элемент массива входит в указанный массив
NotIn	Сравнение значений на "не входит": элемент массива не входит в указанный массив
Overlap	Сравнение значений на "пересекается": массив из элемента исходного массива имеет общие элементы с указанным массивом
NotOverlap	Сравнение значений на "не пересекается": массив из элемента исходного массива не имеет общие элементы с указанным массивом
MatchSearch	Сравнение значений на "удовлетворяет поисковой строке". Поисковая строка может состоять из слов, разделенных пробелами и символами "+", "*" и "?": пробел означает "ИЛИ"; "+" означает "И"; "*" означает любое количество любых символов; "?" означает ровно один символ.
NotMatchSearch	Сравнение значений на "не удовлетворяет поисковой строке". Поисковая строка может состоять из слов, разделенных пробелами и символами "+", "*" и "?": пробел означает "ИЛИ"; "+" означает "И"; "*" означает любое количество любых символов; "?" означает ровно один символ.
ContainedIn	Сравнение значений на "входит": элемент массива входит в указанное значение, при этом все значения преобразуется в строку
NotContainedIn	Сравнение значений на "не входит": элемент массива не входит в указанное значение, при этом все значения преобразуется в строку
IsNull	Сравнение на Null
IsNotNull	Сравнение на "не Null"
Nested	Составной фильтр. Для соединения вложенных фильтров доступны тэги <And>, <Or>, <Not>

Если в качестве значения тэга <Source> указан скаляр, то будет генерироваться ошибка TypeMismatch.

Пример 1. Все элементы массива больше 10

<Array>
  <Source>
    <Structure Type="List">
      <Item>-1</Item>
      <Item>1</Item>
      <Item>30</Item>
      <Item>5</Item>
      <Item>15</Item>
    </Structure>
  </Source>
  <Filter Type="Greater">
    <Value>10</Value>
    <DataType Type="IntegerDataType" />
  </Filter>
</Array>

Результат:

+------+------+
|  30  |  15  |
+------+------+

Пример 2. Все элементы массива больше 0 и меньше 20

<Array>
  <Source>
    <Structure Type="List">
      <Item>-1</Item>
      <Item>1</Item>
      <Item>30</Item>
      <Item>5</Item>
      <Item>15</Item>
    </Structure>
  </Source>
  <Filter Type="Nested">
    <And>
      <Filter Type="Greater">
        <Value>0</Value>
        <DataType Type="IntegerDataType" />
      </Filter>
      <Filter Type="Less">
        <Value>20</Value>
        <DataType Type="IntegerDataType" />
      </Filter>
    </And>
  </Filter>
</Array>

Результат:

+-----+-----+------+
|  1  |  5  |  15  |
+-----+-----+------+

Пример 3. Все элементы матрицы во втором столбце меньше 0

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>2</Item>
        <Item>2</Item>
      </Row>
      <Row>
        <Item>3</Item>
        <Item>-1</Item>
      </Row>
      <Row>
        <Item>4</Item>
        <Item>15</Item>
      </Row>
      <Row>
        <Item>6</Item>
        <Item>-5</Item>
      </Row>
      <Row>
        <Item>7</Item>
        <Item>5</Item>
      </Row>
    </Structure>
  </Source>
  <Filter Type="Less">
    <Index Value="1" />
    <Value>0</Value>
    <DataType Type="IntegerDataType" />
  </Filter>
</Array>

Результат:

+-----+------+
|  3  |  -1  |
|  6  |  -5  |
+-----+------+

Пример 4. Первый столбец матрицы больше 4 и второй в диапазоне от -10 до 10

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>2</Item>
        <Item>2</Item>
      </Row>
      <Row>
        <Item>3</Item>
        <Item>-1</Item>
      </Row>
      <Row>
        <Item>4</Item>
        <Item>15</Item>
      </Row>
      <Row>
        <Item>6</Item>
        <Item>-5</Item>
      </Row>
      <Row>
        <Item>7</Item>
        <Item>5</Item>
      </Row>
    </Structure>
  </Source>
  <Filter Type="Nested">
    <And>
      <Filter Type="Greater">
        <Value>4</Value>
        <DataType Type="IntegerDataType" />
      </Filter>
      <Filter Type="Greater">
        <Index Value="1" />
        <Value>-10</Value>
        <DataType Type="IntegerDataType" />
      </Filter>
      <Filter Type="Less">
        <Index Value="1" />
        <Value>10</Value>
        <DataType Type="IntegerDataType" />
      </Filter>
    </And>
  </Filter>
</Array>

Результат:

+-----+------+
|  6  |  -5  |
|  7  |   5  |
+-----+------+

Соединение

Join

Соединяет исходную матрицу с внешней матрицей по выбранным ключам. Аналог JOIN из SQL.

<Join>
  <OuterArray><!-- Внешная матрица --></OuterArray>
  <Keys>
    <!-- Индекс элемента исходной матрицы -->
    <Inner Index="" Type="" />
    <!-- Индекс элемента внешней матрицы -->
    <Outer Index="" Type="" />
  </Keys>
  <!-- Элементы результирующей матрицы -->
  <Result>
    <!-- Элемент исходной матрицы -->
    <Inner Index="" />
    <!-- Элемент внешней матрицы -->
    <Outer Index="" />
  </Result>
</Join>

В тэге <Keys> указываются индексы элементов, по которым исходная и внешняя матрицы будут соединяться.

В атрибуте Index указывается положительное целочисленное значение, а в атрибуте Type задаётся один из типов.

Количество <Inner> и <Outer> индексов в тэге <Keys>должно совпадать.

Если ключей больше одного, то важен порядок их описания, так как <Inner> и <Outer> индексы сравниваются по парно в порядке описания.

В тэге <Result> указываются индексы элементов исходной и/или внешней матрицы, которые будут добавлены в результирующую матрицу.

Если в качестве значения тэга <Source> указан скаляр, то будет генерироваться ошибка TypeMismatch.

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Source>
  <Join>
    <OuterArray>
      <Structure Type="Table">
        <Row>
          <Item>1</Item>
          <Item>100</Item>
        </Row>
        <Row>
          <Item>3</Item>
          <Item>50</Item>
        </Row>
        <Row>
          <Item>4</Item>
          <Item>95</Item>
        </Row>
      </Structure>
    </OuterArray>
    <Keys>
      <Inner Index="0" Type="IntegerDataType" />
      <Outer Index="0" Type="IntegerDataType" />
    </Keys>
    <Result>
      <Inner Index="0" />
      <Inner Index="1" />
      <Outer Index="1" />
    </Result>
  </Join>
</Array>

Результат:

+-----+----------+-------+
|  1  |  Text 1  |  100  |
+-----+----------+-------+

LeftJoin

Соединяет исходную матрицу с внешней матрицей по выбранным ключам, используя все элементы исходной матрицы. Аналог LEFT JOIN из SQL.

<LeftJoin>
  <OuterArray><!-- Внешная матрица --></OuterArray>
  <Keys>
    <!-- Индекс элемента исходной матрицы -->
    <Inner Index="" Type="" />
    <!-- Индекс элемента внешней матрицы -->
    <Outer Index="" Type="" />
  </Keys>
  <!-- Элементы результирующей матрицы -->
  <Result>
    <!-- Элемент исходной матрицы -->
    <Inner Index="" />
    <!-- Элемент внешней матрицы -->
    <Outer Index="" />
  </Result>
</LeftJoin>

В тэге <Keys> указываются индексы элементов, по которым исходная и внешняя матрицы будут соединяться.

В атрибуте Index указывается положительное целочисленное значение, а в атрибуте Type задаётся один из типов.

Количество <Inner> и <Outer> индексов в тэге <Keys>должно совпадать.

В тэге <Result> указываются индексы элементов исходной и/или внешней матрицы, которые будут добавлены в результирующую матрицу.

Если в качестве значения тэга <Source> указан скаляр, то будет генерироваться ошибка TypeMismatch.

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Source>
  <LeftJoin>
    <OuterArray>
      <Structure Type="Table">
        <Row>
          <Item>1</Item>
          <Item>100</Item>
        </Row>
        <Row>
          <Item>3</Item>
          <Item>50</Item>
        </Row>
        <Row>
          <Item>4</Item>
          <Item>95</Item>
        </Row>
      </Structure>
    </OuterArray>
    <Keys>
      <Inner Index="0" Type="IntegerDataType" />
      <Outer Index="0" Type="IntegerDataType" />
    </Keys>
    <Result>
      <Inner Index="0" />
      <Inner Index="1" />
      <Outer Index="1" />
    </Result>
  </LeftJoin>
</Array>

Результат:

+-----+----------+-------+
|  1  |  Text 1  |  100  |
|  2  |  Text 2  |       |
+-----+----------+-------+

RightJoin

Соединяет исходную матрицу с внешней матрицей по выбранным ключам, используя все элементы внешней матрицы. Аналог RIGHT JOIN из SQL.

<RightJoin>
  <OuterArray><!-- Внешная матрица --></OuterArray>
  <Keys>
    <!-- Индекс элемента исходной матрицы -->
    <Inner Index="" Type="" />
    <!-- Индекс элемента внешней матрицы -->
    <Outer Index="" Type="" />
  </Keys>
  <!-- Элементы результирующей матрицы -->
  <Result>
    <!-- Элемент исходной матрицы -->
    <Inner Index="" />
    <!-- Элемент внешней матрицы -->
    <Outer Index="" />
  </Result>
</RightJoin>

В тэге <Keys> указываются индексы элементов, по которым исходная и внешняя матрицы будут соединяться.

В атрибуте Index указывается положительное целочисленное значение, а в атрибуте Type задаётся один из типов.

Количество <Inner> и <Outer> индексов в тэге <Keys>должно совпадать.

В тэге <Result> указываются индексы элементов исходной и/или внешней матрицы, которые будут добавлены в результирующую матрицу.

Если в качестве значения тэга <Source> указан скаляр, то будет генерироваться ошибка TypeMismatch.

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Source>
  <RightJoin>
    <OuterArray>
      <Structure Type="Table">
        <Row>
          <Item>1</Item>
          <Item>100</Item>
        </Row>
        <Row>
          <Item>3</Item>
          <Item>50</Item>
        </Row>
        <Row>
          <Item>4</Item>
          <Item>95</Item>
        </Row>
      </Structure>
    </OuterArray>
    <Keys>
      <Inner Index="0" Type="IntegerDataType" />
      <Outer Index="0" Type="IntegerDataType" />
    </Keys>
    <Result>
      <Inner Index="0" />
      <Inner Index="1" />
      <Outer Index="1" />
    </Result>
  </RightJoin>
</Array>

Результат:

+-----+----------+-------+
|  1  |  Text 1  |  100  |
|  3  |          |   50  |
|  4  |          |   95  |
+-----+----------+-------+

FullJoin

Соединяет исходную матрицу с внешней матрицей по выбранным ключам, используя все элементы исходной и внешней матриц. Аналог FULL JOIN из SQL.

<FullJoin>
  <OuterArray><!-- Внешная матрица --></OuterArray>
  <Keys>
    <!-- Индекс элемента исходной матрицы -->
    <Inner Index="" Type="" />
    <!-- Индекс элемента внешней матрицы -->
    <Outer Index="" Type="" />
  </Keys>
  <!-- Элементы результирующей матрицы -->
  <Result>
    <!-- Элемент исходной матрицы -->
    <Inner Index="" />
    <!-- Элемент внешней матрицы -->
    <Outer Index="" />
  </Result>
</FullJoin>

В тэге <Keys> указываются индексы элементов, по которым исходная и внешняя матрицы будут соединяться.

В атрибуте Index указывается положительное целочисленное значение, а в атрибуте Type задаётся один из типов.

Количество <Inner> и <Outer> индексов в тэге <Keys>должно совпадать.

В тэге <Result> указываются индексы элементов исходной и/или внешней матрицы, которые будут добавлены в результирующую матрицу.

Если в качестве значения тэга <Source> указан скаляр, то будет генерироваться ошибка TypeMismatch.

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Source>
  <FullJoin>
    <OuterArray>
      <Structure Type="Table">
        <Row>
          <Item>1</Item>
          <Item>100</Item>
        </Row>
        <Row>
          <Item>3</Item>
          <Item>50</Item>
        </Row>
        <Row>
          <Item>4</Item>
          <Item>95</Item>
        </Row>
      </Structure>
    </OuterArray>
    <Keys>
      <Inner Index="0" Type="IntegerDataType" />
      <Outer Index="0" Type="IntegerDataType" />
    </Keys>
    <Result>
      <Inner Index="0" />
      <Inner Index="1" />
      <Outer Index="1" />
    </Result>
  </FullJoin>
</Array>

Результат:

+-----+----------+-------+
|  1  |  Text 1  |  100  |
|  2  |  Text 2  |       |
|     |          |   50  |
|     |          |   95  |
+-----+----------+-------+

Concat

Объединяет два массива с сохранением дубликатов.

<Concat><!-- массив для объединения --></Concat>

При объединении элементов используются следующие правила:

• Матрица объединяется с Матрицей В каждую строку матрицы из тэга <Concat> добавляются пустые элементы, чтобы длина строки соответствовала наибольшей длине строки матрицы, указанной в тэге <Source>, и полученная матрица объединяется с матрицей из тэга <Source>.

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Source>
  <Concat>
    <Structure Type="Table">
      <Row>
        <Item>3</Item>
        <Item>Text 3</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Concat>
</Array>

Результат:

+-----+----------+
|  1  |  Text 1  |
|  2  |  Text 2  |
|  3  |  Text 3  |
|  2  |  Text 2  |
+-----+----------+

• Массив объединяется с Матрицей Массив из тэга <Concat> преобразуется в матрицу. В каждую строку новой матрицы добавляются пустые элементы, чтобы длина строки соответствовала наибольшей длине строки матрицы, указанной в тэге <Source>, и полученная матрица объединяется с матрицей из тэга <Source>.

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Source>
  <Concat>
    <Structure Type="List">
      <Item>3</Item>
      <Item>2</Item>
    </Structure>
  </Concat>
</Array>

Результат:

+-----+----------+
|  1  |  Text 1  |
|  2  |  Text 2  |
|  3  |          |
|  2  |          |
+-----+----------+

• Скаляр объединяется с Матрицей Скаляр из тэга <Concat> преобразуется в матрицу. В единственную строку новой матрицы добавляются пустые элементы, чтобы длина строки соответствовала наибольшей длине строки матрицы, указанной в тэге <Source>, и полученная матрица объединяется с матрицей из тэга <Source>.

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Source>
  <Concat>3</Concat>
</Array>

Результат:

+-----+----------+
|  1  |  Text 1  |
|  2  |  Text 2  |
|  3  |          |
+-----+----------+

• Матрица объединяется с Массивом Матрица из тэга <Concat> преобразуется в массив, при этом берутся первые элементы каждой строки. Полученный массив объединяется с массивом из тэга <Source>.

Пример

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
    </Structure>
  </Source>
  <Concat>
    <Structure Type="Table">
      <Row>
        <Item>3</Item>
        <Item>Text 3</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Concat>
</Array>

Результат:

+-----+-----+-----+-----+
|  1  |  2  |  3  |  2  |
+-----+-----+-----+-----+

• Массив объединяется с Массивом Массив из тэга <Concat> объединяется с массивом из тэга <Source>.

Пример

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
    </Structure>
  </Source>
  <Concat>
    <Structure Type="List">
      <Item>3</Item>
      <Item>2</Item>
    </Structure>
  </Concat>
</Array>

Результат:

+-----+-----+-----+-----+
|  1  |  2  |  3  |  2  |
+-----+-----+-----+-----+

• Скаляр объединяется с Массивом Скаляр из тэга <Concat> преобразуется в массив и объединяется с массивом из тэга <Source>.

Пример

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
    </Structure>
  </Source>
  <Concat>2</Concat>
</Array>

Результат:

+-----+-----+-----+
|  1  |  2  |  2  |
+-----+-----+-----+

• Во всех случаях, когда в качестве значения тэга <Source> указан скаляр, будет генерироваться ошибка TypeMismatch.

Union

Объединяет два массива без сохранения дубликатов.

<Union><!-- массив для объединения --></Union>

При объединении элементов используются следующие правила:

• Матрица объединяется с Матрицей В каждую строку матрицы из тэга <Union> добавляются пустые элементы, чтобы длина строки соответствовала наибольшей длине строки матрицы, указанной в тэге <Source>, и полученная матрица объединяется с матрицей из тэга <Source>.

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Source>
  <Union>
    <Structure Type="Table">
      <Row>
        <Item>3</Item>
        <Item>Text 3</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Union>
</Array>

Результат:

+-----+----------+
|  1  |  Text 1  |
|  2  |  Text 2  |
|  3  |  Text 3  |
+-----+----------+

• Массив объединяется с Матрицей Массив из тэга <Union> преобразуется в матрицу. В каждую строку новой матрицы добавляются пустые элементы, чтобы длина строки соответствовала наибольшей длине строки матрицы, указанной в тэге <Source>, и полученная матрица объединяется с матрицей из тэга <Source>.

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Source>
  <Union>
    <Structure Type="List">
      <Item>3</Item>
      <Item>2</Item>
    </Structure>
  </Union>
</Array>

Результат:

+-----+----------+
|  1  |  Text 1  |
|  2  |  Text 2  |
|  3  |          |
|  2  |          |
+-----+----------+

• Скаляр объединяется с Матрицей Скаляр из тэга <Union> преобразуется в матрицу. В единственную строку новой матрицы добавляются пустые элементы, чтобы длина строки соответствовала наибольшей длине строки матрицы, указанной в тэге <Source>, и полученная матрица объединяется с матрицей из тэга <Source>.

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Source>
  <Union>3</Union>
</Array>

Результат:

+-----+----------+
|  1  |  Text 1  |
|  2  |  Text 2  |
|  3  |          |
+-----+----------+

• Матрица объединяется с Массивом Матрица из тэга <Union> преобразуется в массив, при этом берутся первые элементы каждой строки. Полученный массив объединяется с массивом из тэга <Source>.

Пример

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
    </Structure>
  </Source>
  <Union>
    <Structure Type="Table">
      <Row>
        <Item>3</Item>
        <Item>Text 3</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Union>
</Array>

Результат:

+-----+-----+-----+
|  1  |  2  |  3  |
+-----+-----+-----+

• Массив объединяется с Массивом Массив из тэга <Union> объединяется с массивом из тэга <Source>.

Пример

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
    </Structure>
  </Source>
  <Union>
    <Structure Type="List">
      <Item>3</Item>
      <Item>2</Item>
    </Structure>
  </Union>
</Array>

Результат:

+-----+-----+-----+
|  1  |  2  |  3  |
+-----+-----+-----+

• Скаляр объединяется с Массивом Скаляр из тэга <Union> преобразуется в массив и объединяется с массивом из тэга <Source>.

Пример

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
    </Structure>
  </Source>
  <Union>2</Union>
</Array>

Результат:

+-----+-----+
|  1  |  2  |
+-----+-----+

• Во всех случаях, когда в качестве значения тэга <Source> указан скаляр, будет генерироваться ошибка TypeMismatch.

Group

Группирует элементы массива по указанным индексам. Если в исходном массиве отсутствует элемент с индексом, то вместо него используется значение Null.

<Group> 
  <By Index="" /> 
</Group>

Элементов <By> может быть неограниченное количество.

Если в качестве значения тэга <Source> указан скаляр, то будет генерироваться ошибка TypeMismatch.

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>1</Item>
        <Item>Text 2</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 3</Item>
      </Row>
    </Structure>
  </Source>
  <Group>
    <By Index="0" />
  </Group>
</Array>

Результат:

+-----+------------------+
|  1  |+-----+----------+|
|     ||  1  |  Text 1  ||
|     ||  1  |  Text 2  ||
|     |+-----+----------+|
+-----+-----+------------+
|  2  |+-----+----------+|
|     ||  2  |  Text 3  ||
|     |+-----+----------+|
+-----+------------------+

Т.е. будет таблица из двух колонок и двух строк. В первой строке в первой колонке будет скалярный элемент со значением 1, а во второй колонке будет храниться таблица с двумя строками из источника. Во второй строке во второй колонке будет храниться таблица с одной строкой.

Zip

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

<Zip><!-- элементы для соединения --></Zip>

Длина нового массива соответствует длине наименьшего из массивов.

При объединении элементов используются следующие правила:

• Матрица объединяется с Матрицей В конец каждой строки исходной матрицы добавляются элементы из соответствующей строки матрицы, указанной в тэге <Zip>.

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Source>
  <Zip>
    <Structure Type="Table">
      <Row>
        <Item>3</Item>
        <Item>Text 3</Item>
      </Row>
      <Row>
        <Item>4</Item>
        <Item>Text 4</Item>
      </Row>
      <Row>
        <Item>5</Item>
        <Item>Text 5</Item>
      </Row>
    </Structure>
  </Zip>
</Array>

Результат:

+-----+----------+-----+----------+
|  1  |  Text 1  |  3  |  Text 3  |
|  2  |  Text 2  |  4  |  Text 4  |
+-----+----------+-----+----------+

• Массив объединяется с Матрицей В конец каждой строки исходной матрицы добавляется соответствующий элемент массива, указанного в тэге <Zip>.

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Source>
  <Zip>
    <Structure Type="List">
      <Item>3</Item>
      <Item>4</Item>
      <Item>5</Item>
    </Structure>
  </Zip>
</Array>

Результат:

+-----+----------+-----+
|  1  |  Text 1  |  3  |
|  2  |  Text 2  |  4  |
+-----+----------+-----+

• Скаляр объединяется с Матрицей Скаляр из тэга <Zip> добавляется в конец первой строки исходной матрицы, остальные строки матрицы отбрасываются.

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Source>
  <Zip>3</Zip>
</Array>

Результат:

+-----+----------+-----+
|  1  |  Text 1  |  3  |
+-----+----------+-----+

• Матрица объединяется с Массивом Матрица из тэга <Zip> преобразуется в массив, при этом берутся первые элементы каждой строки. Полученный массив объединяется с массивом из тэга <Source>, при этом элементы массивов образуют строки новой матрицы.

Пример

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
    </Structure>
  </Source>
  <Zip>
    <Structure Type="Table">
      <Row>
        <Item>3</Item>
        <Item>Text 3</Item>
      </Row>
      <Row>
        <Item>4</Item>
        <Item>Text 4</Item>
      </Row>
      <Row>
        <Item>5</Item>
        <Item>Text 5</Item>
      </Row>
    </Structure>
  </Zip>
</Array>

Результат:

+-----+-----+
|  1  |  3  |
|  2  |  4  |
+-----+-----+

• Массив объединяется с Массивом Элемент массив из тэга <Zip> объединяется с соответствующим элементом массива из тэга <Source> так, что образуют строку новой матрицы.

Пример

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
    </Structure>
  </Source>
  <Zip>
    <Structure Type="List">
      <Item>3</Item>
      <Item>4</Item>
      <Item>5</Item>
    </Structure>
  </Zip>
</Array>

Результат:

+-----+-----+
|  1  |  3  |
|  2  |  4  |
+-----+-----+

• Скаляр объединяется с Массивом Скаляр из тэга <Zip> преобразуется в массив, и элементы полученного массива соединяются с элементами массива из тэга <Source>.

Пример

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
    </Structure>
  </Source>
  <Zip>3</Zip>
</Array>

Результат:

+-----+-----+
|  1  |  3  |
+-----+-----+

• Во всех случаях, когда в качестве значения тэга <Source> указан скаляр, будет генерироваться ошибка TypeMismatch.

Выборка из массива

ElementAt

Возвращает элемент массива по заданному индексу. Если индекс элемента отсутствует в массиве, то операция вернёт Null.

<ElementAt><!-- индекс элемента --></ElementAt>

Если в качестве значения тэга <Source> указан скаляр, то будет генерироваться ошибка TypeMismatch.

Пример 1. Поиск в матрице

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
      <Row>
        <Item>3</Item>
        <Item>Text 3</Item>
      </Row>
    </Structure>
  </Source>
  <ElementAt>1</ElementAt>
</Array>

Результат:

+-----+----------+
|  2  |  Text 2  |
+-----+----------+

Пример 2. Поиск в массиве

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
      <Item>3</Item>
    </Structure>
  </Source>
  <ElementAt>1</ElementAt>
</Array>

Результат:

2

Field

Формирует массив из массива словарей. Из каждого словаря достает элемент по ключу, имя которого указано в атрибуте Name тэга <Field>. Если ключ отсутствует в словаре, то возвращается Null.

<Field Name="" />

Если в качестве значения тэга <Source> указан не массив словарей, то выбрасывается исключение TypeMismatch.

Пример

<Array>
  <Source>
    <Structure Type="List">
      <Item>
        <Structure Type="Dictionary">
          <Key Name="Key">Val1</Key>
        </Structure>
      </Item>
      <Item>
        <Structure Type="Dictionary">
          <Key Name="Key">Val2</Key>
        </Structure>
      </Item>
      <Item>
        <Structure Type="Dictionary">
          <Key Name="Key2">Val3</Key>
        </Structure>
      </Item>
    </Structure>
  </Source>
  <Field Name="Key" />
</Array>

Результат:

+--------+--------+--------+
|  Val1  |  Val2  |  NULL  |
+--------+--------+--------+

First

Возвращает первый элемент массива или матрицы. Если массив пустой, то возвращается Null.

<First />

Если в качестве значения тэга <Source> указан скаляр, то будет генерироваться ошибка TypeMismatch.

Пример 1. Первый элемент матрицы

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Source>
  <First />
</Array>

Результат:

+-----+----------+
|  1  |  Text 1  |
+-----+----------+

Пример 2. Первый элемент массива

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
      <Item>3</Item>
      <Item>4</Item>
    </Structure>
  </Source>
  <First />
</Array>

Результат:

1

Last

Возвращает последний элемент массива или матрицы. Если массив пустой, то возвращается Null.

<Last />

Если в качестве значения тэга <Source> указан скаляр, то будет генерироваться ошибка TypeMismatch.

Пример 1. Последний элемент матрицы

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Source>
  <Last />
</Array>

Результат:

+-----+----------+
|  2  |  Text 2  |
+-----+----------+

Пример 2. Последний элемент массива

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
      <Item>3</Item>
      <Item>4</Item>
    </Structure>
  </Source>
  <Last />
</Array>

Результат:

4

Skip

Пропускает указанное количество элементов и возвращает оставшиеся элементы.

<Skip><!-- количество элементов --></Skip>

Если в качестве значения тэга <Source> указан скаляр, то будет генерироваться ошибка TypeMismatch.

Пример 1. Пропуск первых двух элементов в матрице

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
      <Row>
        <Item>3</Item>
        <Item>Text 3</Item>
      </Row>
      <Row>
        <Item>4</Item>
        <Item>Text 4</Item>
      </Row>
    </Structure>
  </Source>
  <Skip>2</Skip>
</Array>

Результат:

+-----+----------+
|  3  |  Text 3  |
|  4  |  Text 4  |
+-----+----------+

Пример 2. Пропуск первых двух элементов в массиве

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
      <Item>3</Item>
      <Item>4</Item>
    </Structure>
  </Source>
  <Skip>2</Skip>
</Array>

Результат:

+-----+-----+
|  3  |  4  |
+-----+-----+

Take

Возвращает указанное количество начальных элементов из исходного массива или матрицы.

<Take><!-- количество элементов --></Take>

Если в качестве значения тэга <Source> указан скаляр, то будет генерироваться ошибка TypeMismatch.

Пример 1. Первые два элемента матрицы

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
      <Row>
        <Item>3</Item>
        <Item>Text 3</Item>
      </Row>
      <Row>
        <Item>4</Item>
        <Item>Text 4</Item>
      </Row>
    </Structure>
  </Source>
  <Take>2</Take>
</Array>

Результат:

+-----+----------+
|  1  |  Text 1  |
|  2  |  Text 2  |
+-----+----------+

Пример 2. Первые два элемента массива

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
      <Item>3</Item>
      <Item>4</Item>
    </Structure>
  </Source>
  <Take>2</Take>
</Array>

Результат:

+-----+-----+
|  1  |  2  |
+-----+-----+

Преобразование

DataTypeFormat

Преобразует элементы массива в строку с использованием формата указанного типа.

<DataTypeFormat Type="" Format="" />

Если в тэге <Source> указана матрица, то будут браться первые элементы всех строк, а затем преобразовываться в строку заданного формата.

Пример

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
      <Item>3</Item>
      <Item>4</Item>
    </Structure>
  </Source>
  <DataTypeFormat Type="DoubleDataType" Format="N2" />
</Array>

Результат:

+--------+--------+--------+--------+
|  1,00  |  2,00  |  3,00  |  4,00  |
+--------+--------+--------+--------+

DataTypeConvert

Приводит элементы массива к заданному типу.

<DataTypeConvert Type="" />

Если в тэге <Source> указана матрица, то все ее элементы будут приводиться к заданному типу.

Пример

<Array>
  <Source>
    <Structure Type="List">
      <Item>1.0</Item>
      <Item>2</Item>
      <Item>3.7</Item>
      <Item>4</Item>
    </Structure>
  </Source>
  <DataTypeConvert Type="DoubleDataType" />
</Array>

Результат:

+-----+-----+-------+-----+
|  1  |  2  |  3,7  |  4  |
+-----+-----+-------+-----+

Distinct

Возвращает уникальные элементы массива.

<Distinct />

Для выборки строк в матрице можно указать индекс столбца, в котором будет проходить проверка уникальности:

<Distinct>
  <On Index="" />
</Distinct>

Тэгов <On> может быть любое количество. Если тэги <On> отсутствуют, то выборка строк происходит по первому столбцу.

Если необходимо проверить все столбцы матрицы, то можно использовать необязательный атрибут AllIndices:

<Distinct AllIndices="True"/>

Если указаны и атрибут AllIndices и тэги <On>, то преимущество отдается атрибуту.

Если в качестве значения тэга <Source> указан скаляр, то будет генерироваться ошибка TypeMismatch.

Пример 1. Уникальные элементы в массиве

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
      <Item>1</Item>
      <Item>4</Item>
    </Structure>
  </Source>
  <Distinct />
</Array>

Результат:

+-----+-----+-----+
|  1  |  2  |  4  |
+-----+-----+-----+

Пример 2. Уникальные элементы в матрице по всем столбцам

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>2</Item>
      </Row>
      <Row>
        <Item>1</Item>
        <Item>1</Item>
      </Row>
      <Row>
        <Item>1</Item>
        <Item>2</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>1</Item>
      </Row>
    </Structure>
  </Source>
  <Distinct>
    <On Index="0" />
    <On Index="1" />
  </Distinct>
</Array>

Результат:

+-----+-----+
|  1  |  2  |
|  1  |  1  |
|  2  |  1  |
+-----+-----+

Пример 3. Уникальные элементы в матрице по одному столбцу

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>2</Item>
      </Row>
      <Row>
        <Item>1</Item>
        <Item>1</Item>
      </Row>
      <Row>
        <Item>1</Item>
        <Item>2</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>1</Item>
      </Row>
    </Structure>
  </Source>
  <Distinct>
    <On Index="1" />
  </Distinct>
</Array>

Результат:

+-----+-----+
|  1  |  2  |
|  1  |  1  |
+-----+-----+

Select

Преобразует массив в другой массив с помощью селекторов.

<Select>
  <Items>
    <Item Type=""></Item>
  </Items>
</Select>

В тэге <Items> указываются селекторы, которые последовательно применяются к каждому элементу исходного массива (для матриц элементом является строка матрицы). Из значений селекторов формируется новый массив или матрица.

Если в качестве значения тэга <Source> указан скаляр, то будет генерироваться ошибка TypeMismatch.

Селекторы можно комбинировать друг с другом.

Поддерживаются селекторы следующих видов:

Index

Выбирает элемент из исходного массива или матрицы.

<Item Type="Index"><!-- индекс элемента --></Item>

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
      <Row>
        <Item>3</Item>
        <Item>Text 3</Item>
      </Row>
    </Structure>
  </Source>
  <Select>
    <Items>
      <Item Type="Index">0</Item>
      <Item Type="Index">0</Item>
      <Item Type="Index">1</Item>
    </Items>
  </Select>
</Array>

Результат:

+-----+-----+----------+
|  1  |  1  |  Text 1  |
|  2  |  2  |  Text 2  |
|  3  |  3  |  Text 3  |
+-----+-----+----------+

Field

Выбор элемент из словаря.

<Item Type="Field"><!-- название поля словаря--></Item>

Пример

<Array>
  <Source>
    <Structure Type="Dictionary">
      <Key Name="Key1">Text 1</Key>
      <Key Name="Key2">Text 2</Key>
      <Key Name="Key3">Text 3</Key>
      <Key Name="Key4">Text 4</Key>
    </Structure>
  </Source>
  <Select>
    <Items>
      <Item Type="Field">Key2</Item>
      <Item Type="Field">Key3</Item>
    </Items>
  </Select>
</Array>

Результат:

+----------+----------+
|  Text 2  |  Text 3  |
+----------+----------+

Value

Подставляет константное значение.

<Item Type="Value "><!-- значение--></Item>

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
      <Row>
        <Item>3</Item>
        <Item>Text 3</Item>
      </Row>
    </Structure>
  </Source>
  <Select>
    <Items>
      <Item Type="Index">0</Item>
      <Item Type="Index">1</Item>
      <Item Type="Value">100</Item>
    </Items>
  </Select>
</Array>

Результат:

+-----+----------+-------+
|  1  |  Text 1  |  100  |
|  2  |  Text 2  |  100  |
|  3  |  Text 3  |  100  |
+-----+----------+-------+

Number

Подставляет порядковый номер элемента. В необязательном атрибуте Start можно задать начальное значение последовательности. По умолчанию используется 0.

<Item Type="Number" Start="" />

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
      <Row>
        <Item>3</Item>
        <Item>Text 3</Item>
      </Row>
    </Structure>
  </Source>
  <Select>
    <Items>
      <Item Type="Number" Start="5"/>
      <Item Type="Index">0</Item>
      <Item Type="Index">1</Item>
    </Items>
  </Select>
</Array>

Результат:

+-----+-----+----------+
|  5  |  1  |  Text 1  |
|  6  |  2  |  Text 2  |
|  7  |  3  |  Text 3  |
+-----+-----+----------+

Expression

Вычисляет выражение на основе данных массива и дополнительных переменных. Тэгов <Item> может быть любое количество. В выражении <Expression> могут использоваться элементы исходного массива (указываются в квадратных скобках []) или дополнительные значения, перечисленные в тэге <Items> (указываются в фигурных скобках {}).

<Item Type="Expression">
  <Expression><!-- выражение --></Expression>
  <Items>
   <!-- дополнительные значения -->
   <Item></Item>
  </Items>
</Item>

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
        <Item>10</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
        <Item>20</Item>
      </Row>
      <Row>
        <Item>3</Item>
        <Item>Text 3</Item>
        <Item>30</Item>
      </Row>
    </Structure>
  </Source>
  <Select>
    <Items>
      <Item Type="Index">0</Item>
      <Item Type="Index">1</Item>
      <Item Type="Expression">
        <Expression>[2] / {0}</Expression>
        <Items>
          <Item>100</Item>
        </Items>
      </Item>      
    </Items>
  </Select>
</Array>

Результат:

+-----+----------+-------+
|  1  |  Text 1  |  0,1  |
|  2  |  Text 2  |  0,2  |
|  3  |  Text 3  |  0,3  |
+-----+----------+-------+

Format

Форматирует элементы массива в строку. В строке формата элементы исходного массива доступны по индексу и указываются в фигурных скобках {}.

<Item Type="Format"><!-- строка формата--></Item>

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>        
        <Item>1</Item>
        <Item>200</Item>
        <Item>2</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>400</Item>
        <Item>1</Item>
      </Row>
      <Row>
        <Item>3</Item>
        <Item>300</Item>
        <Item>1</Item>
      </Row>
    </Structure>
  </Source>
  <Select>
    <Items>
      <Item Type="Index">0</Item>
      <Item Type="Format">Text {2} ({1})</Item>
    </Items>
  </Select>
</Array>

Результат:

+-----+----------------+
|  1  |  Text 2 (200)  |
|  2  |  Text 1 (400)  |
|  3  |  Text 1 (300)  |
+-----+----------------+

Action

Элемент на основе вложенного массива. В тэге <Actions> указываются операции по работе с массивами аналогично тэгу <Array>. Исходным массивом для первой операции будет элемент массива с индексом из тэга <Index>.

<Item Type="Action">
  <Index><!-- индекс элемента исходного массива --></Index>
  <Actions></Actions>
</Item>

Пример 1. Группировка строк по первому столбцу и расчет суммы вторых столбцов для каждой группы

<Array>
  <Source>
    <Structure Type="Table">
      <Row>        
        <Item>1</Item>
        <Item>200</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>400</Item>
      </Row>
      <Row>
        <Item>1</Item>
        <Item>300</Item>
      </Row>
    </Structure>
  </Source>
  <Group>
    <By Index="0" />
  </Group>
  <Select>
    <Items>
      <Item Type="Index">0</Item>
      <Item Type="Action">
        <Index>1</Index>
        <!-- работаем с вложенным массивом -->
        <Actions>
          <Select>
            <Items>
              <!-- второй элемент вложенного массива -->
              <Item Type="Index">1</Item>
            </Items>
          </Select>
          <Sum Type="IntegerDataType" />
        </Actions>
      </Item>
    </Items>
  </Select>
</Array>

Результат:

+-----+-------+
|  1  |  500  |
|  2  |  400  |
+-----+-------+

Пример 2. Расчет суммы элементов для каждого массива в массиве

<Array>
  <Source>
    <Structure Type="List">
      <Item>
        <Structure Type="List">
          <Item>1</Item>
          <Item>200</Item>
          <Item>80</Item>
        </Structure>
      </Item>
      <Item>
        <Structure Type="List">
          <Item>2</Item>
          <Item>400</Item>
          <Item>50</Item>
        </Structure>
      </Item>
      <Item>
        <Structure Type="List">
          <Item>1</Item>
          <Item>300</Item>
          <Item>20</Item>
        </Structure>
      </Item>
    </Structure>
  </Source>
  <Select>
    <Items>
      <Item Type="Action">
        <!-- Указывать индекс элемента исходного массива не обязательно -->
        <Index>0</Index>
        <Actions>
          <Sum Type="IntegerDataType" />
        </Actions>
      </Item>
    </Items>
  </Select>
</Array>

Результат:

+-------+-------+-------+
|  281  |  452  |  321  |
+-------+-------+-------+

Substitution

Выбор значения из таблицы подстановки. В качестве таблицы подстановки должна быть матрица, состоящая из двух столбцов. В первом столбце должен быть ключ, по которому будет идти подстановка, а во втором - значение, которое будет использоваться при подстановке.

<Item Type="Substitution">
  <Index><!-- индекс элемента исходного массива --></Index>
  <Value><!-- таблица подстановки --></Value>
</Item>

Пример

<Array>
  <Source>
    <Structure Type="Table">
      <Row>        
        <Item>1</Item>
        <Item>2</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>1</Item>
      </Row>
      <Row>
        <Item>3</Item>
        <Item>1</Item>
      </Row>
    </Structure>
  </Source>
  <Select>
    <Items>
      <Item Type="Index">0</Item>
      <Item Type="Substitution">
        <Index>1</Index>
        <Value>
          <Structure Type="Table">
            <Row>
              <Item>1</Item>
              <Item>Text 1</Item>
            </Row>
            <Row>
              <Item>2</Item>
              <Item>Text 2</Item>
            </Row>
          </Structure>
        </Value>
      </Item>
    </Items>
  </Select>
</Array>

Результат:

+-----+----------+
|  1  |  Text 2  |
|  2  |  Text 1  |
|  3  |  Text 1  |
+-----+----------+

SelectMany

Объединяет строки матрицы в одномерный массив.

<SelectMany />

Если в качестве значения тэга <Source> указан скаляр, то будет генерироваться ошибка TypeMismatch.

Пример

<Array>
  <Source>
    <Structure Type="List">
      <Item>
        <Structure Type="List">
          <Item>1</Item>
          <Item>80</Item>
        </Structure>
      </Item>
      <Item>
        <Structure Type="List">
          <Item>2</Item>
          <Item>50</Item>
        </Structure>
      </Item>
      <Item>
        <Structure Type="List">
          <Item>3</Item>
          <Item>20</Item>
        </Structure>
      </Item>
    </Structure>
  </Source>
  <SelectMany />
</Array>

Результат:

+-----+------+-----+------+-----+------+
|  1  |  80  |  2  |  50  |  3  |  20  |
+-----+------+-----+------+-----+------+

StringJoin

Форматирует входящее значение в строку.

<StringJoin Separator="" LineSeparator="" />

Обязательный атрибут Separator используется для задания разделителя элементов массива или элементов строки матрицы.

Необязательный атрибут LineSeparator используется для задания разделителя строк в матрице. По умолчанию используется значение, указанное в атрибуте Separator.

Для задания "новой" строки используется сочетание символов: \r\n.

Пример 1. Массив массивов

<Array>
  <Source>
    <Structure Type="List">
      <Item>
        <Structure Type="List">
          <Item>1</Item>
          <Item>80</Item>
        </Structure>
      </Item>
      <Item>
        <Structure Type="List">
          <Item>2</Item>
          <Item>50</Item>
        </Structure>
      </Item>
    </Structure>
  </Source>
  <StringJoin Separator="; " LineSeparator="\r\n" />
</Array>

Результат:

1; 80; 2; 50

Пример 2. Матрица

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
      <Row>
        <Item>3</Item>
        <Item>Text 3</Item>
      </Row>
    </Structure>
  </Source>
  <StringJoin Separator="; " LineSeparator="\r\n" />
</Array>

Результат:

1; Text 1
2; Text 2
3; Text 3

Пример 3. Массив

<Array>
  <Source>
    <Structure Type="List">
      <Item>Text 1</Item>
      <Item>Text 2</Item>
      <Item>Text 3</Item>
    </Structure>
  </Source>
  <StringJoin Separator="; "  />
</Array>

Результат:

Text 1; Text 2; Text 3

StringSplit

Преобразует входное значение в строку, которую затем разделяет по заданному разделителю.

<StringSplit Separator="" />

Обязательный атрибут Separator используется для задания разделителя, по которому строка будет разделена.

Для разбиения по "новой" строке используется сочетание символов: \r\n.

Так как тэг <Source> всегда возвращает массив, то необходимо использовать тэг <First> (или любой другой способ), чтобы получить элемент массива, которой будет преобразовываться в строку и разбиваться по заданному разделителю.

Если в качестве значения тэга <Source> указано не скалярное значение, то будет генерироваться ошибка TypeMismatch.

Пример

<Array>
  <Source>1, 2, 3, 4</Source>
  <First />
  <StringSplit Separator=", " />
</Array>

Результат:

+-----+-----+-----+-----+
|  1  |  2  |  3  |  4  |
+-----+-----+-----+-----+

ToDictionary

Преобразует массив в массив словарей.

<ToDictionary>
  <Key Name="" Index="" />
</ToDictionary>

Тэгов <Key> может быть произвольное количество.

В атрибуте Name указывается название ключа словаря.

В атрибуте Index указывается индекс элемента массива, который будет записан в словарь по ключу Name.

Если в качестве значения тэга <Source> указан скаляр, то будет генерироваться ошибка TypeMismatch.

Пример 1. Массив преобразуется в словарь

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
      <Item>1</Item>
      <Item>4</Item>
    </Structure>
  </Source>
  <ToDictionary>
    <Key Name="Id" Index="0" />
  </ToDictionary>
</Array>

Результат:

[
   { "Id":"1" },
   { "Id":"2" },
   { "Id":"1" },
   { "Id":"4" }
]

Пример 2. Матрица преобразуется в словарь

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>1</Item>
        <Item>100</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>38</Item>
      </Row>
      <Row>
        <Item>3</Item>
        <Item>26</Item>
      </Row>
    </Structure>
  </Source>
  <ToDictionary>
    <Key Name="Id" Index="0" />
    <Key Name="Count"  Index="1" />
  </ToDictionary>
</Array>

Результат:

[
   {"Id":"1","Count":"100"},
   {"Id":"2","Count":"38"},
   {"Id":"3","Count":"26"}
]

ToTable

Преобразует массив или скалярное значение в матрицу.

<ToTable />

Преобразование происходит по следующим правилам:

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

Пример

<Array>
  <Source>
    <Structure Type="List">
      <Item>1</Item>
      <Item>2</Item>
      <Item>3</Item>
      <Item>4</Item>
    </Structure>
  </Source>
  <ToTable /> 
</Array>

Результат:

+-----+
|  1  |
|  2  |
|  3  |
|  4  |
+-----+

• Скаляр преобразуется в матрицу Создается матрица из одной строки, в которую пишется входное скалярное значение.

Пример

<Array>
  <Source>2</Source>
  <ToTable />
</Array>

Результат:

+-----+
|  2  |
+-----+

ToArray

Преобразует входное значение в массив, если значение скаляр, для массивов возвращает исходное значение.

<ToArray />

Пример

<Array>
  <Source>10</Source>
  <ToArray />
</Array>

Результат:

+------+
|  10  |
+------+

Сортировка

Order

Сортирует элементы массива и матрицы по указанным индексам.

<Order> 
  <By Index="" Type="" /> 
</Order>

Тэгов <By> может быть неограниченное количество.

В атрибуте Index указывается индекс элемента строки матрицы, по которому будет происходить сортировка. Если в исходном матрице отсутствует элемент с указанным индексом, то такое условие сортировки будет игнорироваться.

В необязательном атрибуте Type указывается тип сортировки: Asc для сортировки элементов по возрастанию (значение по умолчанию) или Desc для сортировки по убыванию.

Если в качестве значения тэга <Source> указан скаляр, то будет генерироваться ошибка TypeMismatch.

Пример 1. Сортировка матрицы по одному столбцу

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>3</Item>
        <Item>Text 3</Item>
      </Row>
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
      <Row>
        <Item>1</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Source>
  <Order>
    <By Index="0" />
  </Order>
</Array>

Результат:

+-----+----------+
|  1  |  Text 1  |
|  1  |  Text 2  |
|  2  |  Text 2  |
|  3  |  Text 3  |
+-----+----------+

Пример 2. Сортировка матрицы по двум столбцам

<Array>
  <Source>
    <Structure Type="Table">
      <Row>
        <Item>3</Item>
        <Item>Text 3</Item>
      </Row>
      <Row>
        <Item>1</Item>
        <Item>Text 1</Item>
      </Row>
      <Row>
        <Item>2</Item>
        <Item>Text 2</Item>
      </Row>
      <Row>
        <Item>1</Item>
        <Item>Text 2</Item>
      </Row>
    </Structure>
  </Source>
  <Order>
    <By Index="0" />
    <By Index="1" Type="Desc"/>
  </Order>
</Array>

Результат:

+-----+----------+
|  1  |  Text 2  |
|  1  |  Text 1  |
|  2  |  Text 2  |
|  3  |  Text 3  |
+-----+----------+

Пример 3. Сортировка массива по убыванию

<Array>
  <Source>
    <Structure Type="List">
      <Item>3</Item>
      <Item>4</Item>
      <Item>1</Item>
      <Item>2</Item>
    </Structure>
  </Source>
  <Order>
    <By Index="0"  Type="Desc"/>
  </Order>
</Array>

Результат:

+-----+-----+-----+-----+
|  4  |  3  |  2  |  1  |
+-----+-----+-----+-----+

Sort

Сортирует элементы одномерного массива.

<Sort />

Если в качестве значения тэга <Source> указан скаляр или матрица, то будет генерироваться ошибка TypeMismatch.

Пример

<Array>
  <Source>
    <Structure Type="List">
      <Item>3</Item>
      <Item>4</Item>
      <Item>1</Item>
      <Item>2</Item>
    </Structure>
  </Source>
  <Sort />
</Array>

Результат:

+-----+-----+-----+-----+
|  1  |  2  |  3  |  4  |
+-----+-----+-----+-----+