# Array

## Шаблон Array <a href="#template_input" id="template_input"></a>

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

```xml
<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>
```

<details>

<summary>Полный шаблон Array</summary>

```xml
<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>
```

</details>

## Описание Array <a href="#description_input" id="description_input"></a>

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

```xml
<Array>
  <Source></Source>
  <Operation1></Operation1>
  <Operation2></Operation2>
</Array>
```

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

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

* Изменение
* Агрегация
* Поиск
* Соединение
* Выборка из массива
* Преобразование
* Сортировка

## Изменение

### Add

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

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

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

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+----------+
```

</details>

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

<details>

<summary>Пример</summary>

```xml
<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  |          |
+-----+---------+----------+
```

</details>

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

<details>

<summary>Пример</summary>

```xml
<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  |         |          |
+-----+---------+----------+
```

</details>

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+-----+-----+-----+
```

</details>

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+-----+-----+-----+
```

</details>

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

<details>

<summary>Пример</summary>

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

Результат:

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

</details>

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

### InsertAt <a href="#insert_at" id="insert_at"></a>

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

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

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

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+----------+
```

</details>

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+---------+----------+
```

</details>

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+---------+----------+
```

</details>

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+-----+-----+-----+
```

</details>

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+-----+-----+-----+
```

</details>

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+-----+-----+
```

</details>

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

### Update

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

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

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

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+---------+----------+
```

</details>

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+---------+----------+
```

</details>

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+-----+
```

</details>

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+-----+
```

</details>

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

<details>

<summary>Пример</summary>

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

Результат:

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

</details>

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

### Remove

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

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

{% hint style="warning" %}
Если в качестве значения тэга `<Source>` указан **скаляр**, то будет генерироваться ошибка **TypeMismatch**.
{% endhint %}

<details>

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

```xml
<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  |
+-----+----------+
```

</details>

<details>

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

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

Результат:

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

</details>

<details>

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

```xml
<<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  |
+-----+----------+
```

</details>

## Агрегация

### Aggregate

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

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

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

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

{% hint style="info" %}
Для вычисления выражений используется **NCalc**.
{% endhint %}

{% hint style="warning" %}
Если в качестве значения тэга `<Source>` указан **скаляр**, то будет генерироваться ошибка **TypeMismatch**.
{% endhint %}

<details>

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

```xml
<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  |
+------+------+
```

</details>

<details>

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

```xml
<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
```

</details>

### Count

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

```xml
<Count />
```

{% hint style="warning" %}
Если в качестве значения тэга `<Source>` указан **скаляр**, то будет генерироваться ошибка **TypeMismatch**.
{% endhint %}

<details>

<summary>Пример</summary>

```xml
<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
```

</details>

### Max

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

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

В атрибуте `Type` задаётся один из [типов](https://wfsys.gitbook.io/workflow-forms-syntax/workflow_forms/data_types).

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

{% hint style="warning" %}
Если в качестве значения тэга `<Source>` указан **скаляр**, то будет генерироваться ошибка **TypeMismatch**.
{% endhint %}

<details>

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

```xml
<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
```

</details>

<details>

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

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

Результат:

```
10
```

</details>

### Min

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

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

В атрибуте `Type` задаётся один из [типов](https://wfsys.gitbook.io/workflow-forms-syntax/workflow_forms/data_types).

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

{% hint style="warning" %}
Если в качестве значения тэга `<Source>` указан **скаляр**, то будет генерироваться ошибка **TypeMismatch**.
{% endhint %}

<details>

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

```xml
<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
```

</details>

<details>

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

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

Результат:

```
2
```

</details>

### Sum

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

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

В атрибуте `Type` задаётся один из [типов](https://wfsys.gitbook.io/workflow-forms-syntax/workflow_forms/data_types).

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

{% hint style="warning" %}
Если в качестве значения тэга `<Source>` указан **скаляр**, то будет генерироваться ошибка **TypeMismatch**.
{% endhint %}

<details>

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

```xml
<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
```

</details>

<details>

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

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

Результат:

```
24
```

</details>

## Поиск

### IndexOf

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

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

В необязательном атрибуте `Type` тэга `<IndexOf>` указывается [тип сравнения значений](#tipy-sravneniya-znachenii). По умолчанию используется фильтр Equal.

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

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

Тэг [`<DataType>`](https://wfsys.gitbook.io/workflow-forms-syntax/workflow_forms/data_types) задаёт тип элемента. По умолчанию используется тип **StringDataType**.

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

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

<table data-header-hidden><thead><tr><th align="center"></th><th width="459.3333333333333"></th></tr></thead><tbody><tr><td align="center">Equal</td><td>Сравнение значений на равенство</td></tr><tr><td align="center">NotEqual</td><td>Сравнение значений на неравенство</td></tr><tr><td align="center">Greater</td><td>Сравнение значений на "больше": элемент массива больше указанного значения</td></tr><tr><td align="center">GreaterOrEqual</td><td>Сравнение значений на "больше или равно": элемент массива больше или равен указанному значению</td></tr><tr><td align="center">Less</td><td>Сравнение значений на "меньше": элемент массива меньше указанного значения</td></tr><tr><td align="center">LessOrEqual</td><td>Сравнение значений на "меньше или равно": элемент массива меньше или равен указанному значению</td></tr><tr><td align="center">Contains</td><td>Сравнение значений на "содержит": элемент массива содержит указанное значение, при этом все значения преобразуется в строку</td></tr><tr><td align="center">NotContains</td><td>Сравнение значений на "не содержит": элемент массива не содержит указанное значение, при этом все значения преобразуется в строку</td></tr><tr><td align="center">In</td><td>Сравнение значений на "входит": элемент массива входит в указанный массив</td></tr><tr><td align="center">NotIn</td><td>Сравнение значений на "не входит": элемент массива не входит в указанный массив</td></tr><tr><td align="center">Overlap</td><td>Сравнение значений на "пересекается": массив из элемента исходного массива имеет общие элементы с указанным массивом</td></tr><tr><td align="center">NotOverlap</td><td>Сравнение значений на "не пересекается": массив из элемента исходного массива не имеет общие элементы с указанным массивом</td></tr><tr><td align="center">MatchSearch</td><td><p>Сравнение значений на "удовлетворяет поисковой строке". Поисковая строка может состоять из слов, разделенных пробелами и символами "+", "*" и "?":</p><ul><li>пробел означает "ИЛИ";</li><li>"+" означает "И";</li><li>"*" означает любое количество любых символов;</li><li>"?" означает ровно один символ.</li></ul></td></tr><tr><td align="center">NotMatchSearch</td><td><p>Сравнение значений на "не удовлетворяет поисковой строке". </p><p>Поисковая строка может состоять из слов, разделенных пробелами и символами "+", "*" и "?":</p><ul><li>пробел означает "ИЛИ";</li><li>"+" означает "И";</li><li>"*" означает любое количество любых символов;</li><li>"?" означает ровно один символ.</li></ul></td></tr><tr><td align="center">ContainedIn</td><td>Сравнение значений на "входит": элемент массива входит в указанное значение, при этом все значения преобразуется в строку</td></tr><tr><td align="center">NotContainedIn</td><td>Сравнение значений на "не входит": элемент массива не входит в указанное значение, при этом все значения преобразуется в строку</td></tr><tr><td align="center">IsNull</td><td>Сравнение на Null</td></tr><tr><td align="center">IsNotNull</td><td>Сравнение на "не Null"</td></tr><tr><td align="center">Nested</td><td>Составной фильтр. Для соединения вложенных фильтров (<a href="#filter"><code>&#x3C;Filter></code></a>) доступны тэги <code>&#x3C;And></code>, <code>&#x3C;Or></code>, <code>&#x3C;Not></code></td></tr></tbody></table>

{% hint style="warning" %}
Если в качестве значения тэга `<Source>` указан **скаляр**, то будет генерироваться ошибка **TypeMismatch**.
{% endhint %}

<details>

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

```xml
<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
```

</details>

<details>

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

```xml
<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
```

</details>

<details>

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

```xml
<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
```

</details>

<details>

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

```xml
<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
```

</details>

### Filter

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

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

В необязательном атрибуте `Type` тэга `<Filter>` указывается [тип фильтра](#tipy-sravneniya-znachenii-1). По умолчанию используется фильтр Equal.

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

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

Тэг [`<DataType>`](https://wfsys.gitbook.io/workflow-forms-syntax/workflow_forms/data_types) задаёт тип элемента. По умолчанию используется тип **StringDataType**.

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

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

<table data-header-hidden><thead><tr><th align="center"></th><th width="459.3333333333333"></th></tr></thead><tbody><tr><td align="center">Equal</td><td>Сравнение значений на равенство</td></tr><tr><td align="center">NotEqual</td><td>Сравнение значений на неравенство</td></tr><tr><td align="center">Greater</td><td>Сравнение значений на "больше": элемент массива больше указанного значения</td></tr><tr><td align="center">GreaterOrEqual</td><td>Сравнение значений на "больше или равно": элемент массива больше или равен указанному значению</td></tr><tr><td align="center">Less</td><td>Сравнение значений на "меньше": элемент массива меньше указанного значения</td></tr><tr><td align="center">LessOrEqual</td><td>Сравнение значений на "меньше или равно": элемент массива меньше или равен указанному значению</td></tr><tr><td align="center">Contains</td><td>Сравнение значений на "содержит": элемент массива содержит указанное значение, при этом все значения преобразуется в строку</td></tr><tr><td align="center">NotContains</td><td>Сравнение значений на "не содержит": элемент массива не содержит указанное значение, при этом все значения преобразуется в строку</td></tr><tr><td align="center">In</td><td>Сравнение значений на "входит": элемент массива входит в указанный массив</td></tr><tr><td align="center">NotIn</td><td>Сравнение значений на "не входит": элемент массива не входит в указанный массив</td></tr><tr><td align="center">Overlap</td><td>Сравнение значений на "пересекается": массив из элемента исходного массива имеет общие элементы с указанным массивом</td></tr><tr><td align="center">NotOverlap</td><td>Сравнение значений на "не пересекается": массив из элемента исходного массива не имеет общие элементы с указанным массивом</td></tr><tr><td align="center">MatchSearch</td><td><p>Сравнение значений на "удовлетворяет поисковой строке". Поисковая строка может состоять из слов, разделенных пробелами и символами "+", "*" и "?":</p><ul><li>пробел означает "ИЛИ";</li><li>"+" означает "И";</li><li>"*" означает любое количество любых символов;</li><li>"?" означает ровно один символ.</li></ul></td></tr><tr><td align="center">NotMatchSearch</td><td><p>Сравнение значений на "не удовлетворяет поисковой строке". </p><p>Поисковая строка может состоять из слов, разделенных пробелами и символами "+", "*" и "?":</p><ul><li>пробел означает "ИЛИ";</li><li>"+" означает "И";</li><li>"*" означает любое количество любых символов;</li><li>"?" означает ровно один символ.</li></ul></td></tr><tr><td align="center">ContainedIn</td><td>Сравнение значений на "входит": элемент массива входит в указанное значение, при этом все значения преобразуется в строку</td></tr><tr><td align="center">NotContainedIn</td><td>Сравнение значений на "не входит": элемент массива не входит в указанное значение, при этом все значения преобразуется в строку</td></tr><tr><td align="center">IsNull</td><td>Сравнение на Null</td></tr><tr><td align="center">IsNotNull</td><td>Сравнение на "не Null"</td></tr><tr><td align="center">Nested</td><td>Составной фильтр. Для соединения вложенных фильтров доступны тэги <code>&#x3C;And></code>, <code>&#x3C;Or></code>, <code>&#x3C;Not></code></td></tr></tbody></table>

{% hint style="warning" %}
Если в качестве значения тэга `<Source>` указан **скаляр**, то будет генерироваться ошибка **TypeMismatch**.
{% endhint %}

<details>

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

```xml
<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  |
+------+------+
```

</details>

<details>

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

```xml
<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  |
+-----+-----+------+
```

</details>

<details>

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

```xml
<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  |
+-----+------+
```

</details>

<details>

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

```xml
<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  |
+-----+------+
```

</details>

## Соединение

### Join

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

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

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

В атрибуте `Index` указывается положительное целочисленное значение, а в атрибуте `Type` задаётся один из [типов](https://wfsys.gitbook.io/workflow-forms-syntax/workflow_forms/data_types).

{% hint style="warning" %}
Количество `<Inner>` и `<Outer>` индексов в тэге `<Keys>`должно совпадать.

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

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

{% hint style="warning" %}
Если в качестве значения тэга `<Source>` указан **скаляр**, то будет генерироваться ошибка **TypeMismatch**.
{% endhint %}

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+----------+-------+
```

</details>

### LeftJoin <a href="#left_join" id="left_join"></a>

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

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

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

В атрибуте `Index` указывается положительное целочисленное значение, а в атрибуте `Type` задаётся один из [типов](https://wfsys.gitbook.io/workflow-forms-syntax/workflow_forms/data_types).

{% hint style="warning" %}
Количество `<Inner>` и `<Outer>` индексов в тэге `<Keys>`должно совпадать.
{% endhint %}

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

{% hint style="warning" %}
Если в качестве значения тэга `<Source>` указан **скаляр**, то будет генерироваться ошибка **TypeMismatch**.
{% endhint %}

<details>

<summary>Пример</summary>

```xml
<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  |       |
+-----+----------+-------+
```

</details>

### RightJoin <a href="#right_join" id="right_join"></a>

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

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

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

В атрибуте `Index` указывается положительное целочисленное значение, а в атрибуте `Type` задаётся один из [типов](https://wfsys.gitbook.io/workflow-forms-syntax/workflow_forms/data_types).

{% hint style="warning" %}
Количество `<Inner>` и `<Outer>` индексов в тэге `<Keys>`должно совпадать.
{% endhint %}

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

{% hint style="warning" %}
Если в качестве значения тэга `<Source>` указан **скаляр**, то будет генерироваться ошибка **TypeMismatch**.
{% endhint %}

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+----------+-------+
```

</details>

### FullJoin <a href="#full_join" id="full_join"></a>

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

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

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

В атрибуте `Index` указывается положительное целочисленное значение, а в атрибуте `Type` задаётся один из [типов](https://wfsys.gitbook.io/workflow-forms-syntax/workflow_forms/data_types).

{% hint style="warning" %}
Количество `<Inner>` и `<Outer>` индексов в тэге `<Keys>`должно совпадать.
{% endhint %}

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

{% hint style="warning" %}
Если в качестве значения тэга `<Source>` указан **скаляр**, то будет генерироваться ошибка **TypeMismatch**.
{% endhint %}

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+----------+-------+
```

</details>

### Concat

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

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

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

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+----------+
```

</details>

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

<details>

<summary>Пример</summary>

```xml
<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  |          |
+-----+----------+
```

</details>

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

<details>

<summary>Пример</summary>

```xml
<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  |          |
+-----+----------+
```

</details>

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+-----+-----+-----+
```

</details>

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+-----+-----+-----+
```

</details>

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

<details>

<summary>Пример</summary>

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

Результат:

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

</details>

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

### Union

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

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

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

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+----------+
```

</details>

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

<details>

<summary>Пример</summary>

```xml
<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  |          |
+-----+----------+
```

</details>

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

<details>

<summary>Пример</summary>

```xml
<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  |          |
+-----+----------+
```

</details>

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+-----+-----+
```

</details>

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+-----+-----+
```

</details>

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

<details>

<summary>Пример</summary>

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

Результат:

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

</details>

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

### Group

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

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

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

{% hint style="warning" %}
Если в качестве значения тэга `<Source>` указан **скаляр**, то будет генерироваться ошибка **TypeMismatch**.
{% endhint %}

<details>

<summary>Пример</summary>

```xml
<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, а во второй колонке будет храниться таблица с двумя строками из источника. Во второй строке во второй колонке будет храниться таблица с одной строкой.

</details>

### Zip

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

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

{% hint style="info" %}
Длина нового массива соответствует длине наименьшего из массивов.

Так же стоит учитывать момент, когда один из соединяемых массивов возвращает null, то в качестве результат соединения так же будет null.
{% endhint %}

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

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+----------+-----+----------+
```

</details>

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+----------+-----+
```

</details>

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+----------+-----+
```

</details>

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+-----+
```

</details>

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+-----+
```

</details>

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

<details>

<summary>Пример</summary>

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

Результат:

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

</details>

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

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

### ElementAt <a href="#element_at" id="element_at"></a>

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

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

{% hint style="warning" %}
Если в качестве значения тэга `<Source>` указан **скаляр**, то будет генерироваться ошибка **TypeMismatch**.
{% endhint %}

<details>

<summary>Пример 1. Поиск в матрице</summary>

```xml
<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  |
+-----+----------+
```

</details>

<details>

<summary>Пример 2. Поиск в массиве</summary>

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

Результат:

```
2
```

</details>

### Field

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

```xml
<Field Name="" />
```

{% hint style="warning" %}
Если в качестве значения тэга `<Source>` указан **не массив словарей**, то выбрасывается исключение **TypeMismatch**.
{% endhint %}

<details>

<summary>Пример</summary>

```xml
<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  |
+--------+--------+--------+
```

</details>

### First

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

```xml
<First />
```

{% hint style="warning" %}
Если в качестве значения тэга `<Source>` указан **скаляр**, то будет генерироваться ошибка **TypeMismatch**.
{% endhint %}

<details>

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

```xml
<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  |
+-----+----------+
```

</details>

<details>

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

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

Результат:

```
1
```

</details>

### Last

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

```xml
<Last />
```

{% hint style="warning" %}
Если в качестве значения тэга `<Source>` указан **скаляр**, то будет генерироваться ошибка **TypeMismatch**.
{% endhint %}

<details>

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

```xml
<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  |
+-----+----------+
```

</details>

<details>

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

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

Результат:

```
4
```

</details>

### Skip

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

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

{% hint style="warning" %}
Если в качестве значения тэга `<Source>` указан **скаляр**, то будет генерироваться ошибка **TypeMismatch**.
{% endhint %}

<details>

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

```xml
<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  |
+-----+----------+
```

</details>

<details>

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

```xml
<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  |
+-----+-----+
```

</details>

### Take

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

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

{% hint style="warning" %}
Если в качестве значения тэга `<Source>` указан **скаляр**, то будет генерироваться ошибка **TypeMismatch**.
{% endhint %}

<details>

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

```xml
<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  |
+-----+----------+
```

</details>

<details>

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

```xml
<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  |
+-----+-----+
```

</details>

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

### DataTypeFormat <a href="#data_type_format" id="data_type_format"></a>

Преобразует элементы массива в строку с использованием формата указанного [типа](https://wfsys.gitbook.io/workflow-forms-syntax/workflow_forms/data_types).

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

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

<details>

<summary>Пример</summary>

```xml
<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  |
+--------+--------+--------+--------+
```

</details>

### DataTypeConvert <a href="#data_type_convert" id="data_type_convert"></a>

Приводит элементы массива к заданному [типу](https://wfsys.gitbook.io/workflow-forms-syntax/workflow_forms/data_types).

```xml
<DataTypeConvert Type="" />
```

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+-----+-------+-----+
```

</details>

### Distinct

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

```xml
<Distinct />
```

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

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

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

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

```xml
<Distinct AllIndices="True"/>
```

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

{% hint style="warning" %}
Если в качестве значения тэга `<Source>` указан **скаляр**, то будет генерироваться ошибка **TypeMismatch**.
{% endhint %}

<details>

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

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

Результат:

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

</details>

<details>

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

```xml
<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  |
+-----+-----+
```

</details>

<details>

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

```xml
<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  |
+-----+-----+
```

</details>

### Select

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

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

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

{% hint style="warning" %}
Если в качестве значения тэга `<Source>` указан **скаляр**, то будет генерироваться ошибка **TypeMismatch**.
{% endhint %}

{% hint style="info" %}
Селекторы можно комбинировать друг с другом.
{% endhint %}

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

#### **Index**  <a href="#select-index" id="select-index"></a>

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

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+-----+----------+
```

</details>

#### **Field** <a href="#select-field" id="select-field"></a>

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

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

<details>

<summary>Пример</summary>

```xml
<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  |
+----------+----------+
```

</details>

#### **Value** <a href="#select-value" id="select-value"></a>

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

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+----------+-------+
```

</details>

#### **Number** <a href="#select-number" id="select-number"></a>

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

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+-----+----------+
```

</details>

#### **Expression** <a href="#select-expression" id="select-expression"></a>

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

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+----------+-------+
```

</details>

#### **Format** <a href="#select-format" id="select-format"></a>

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

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

<details>

<summary>Пример</summary>

```xml
<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)  |
+-----+----------------+
```

</details>

#### **Action** <a href="#select-action" id="select-action"></a>

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

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

<details>

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

```xml
<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  |
+-----+-------+
```

</details>

<details>

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

```xml
<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  |
+-------+-------+-------+
```

</details>

#### **Substitution** <a href="#select-substitution" id="select-substitution"></a>

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

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+----------+
```

</details>

### SelectMany <a href="#select_many" id="select_many"></a>

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

```xml
<SelectMany />
```

{% hint style="warning" %}
Если в качестве значения тэга `<Source>` указан **скаляр**, то будет генерироваться ошибка **TypeMismatch**.
{% endhint %}

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+------+-----+------+-----+------+
```

</details>

### StringJoin <a href="#string_join" id="string_join"></a>

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

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

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

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

{% hint style="info" %}
Для задания "новой" строки используется сочетание символов: `\r\n`.&#x20;
{% endhint %}

<details>

<summary>Пример 1. Массив массивов</summary>

```xml
<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
```

</details>

<details>

<summary>Пример 2. Матрица</summary>

```xml
<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
```

</details>

<details>

<summary>Пример 3. Массив</summary>

```xml
<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
```

</details>

### StringSplit <a href="#string_split" id="string_split"></a>

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

```xml
<StringSplit Separator="" />
```

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

{% hint style="info" %}
Для разбиения по "новой" строке используется сочетание символов: `\r\n`.&#x20;
{% endhint %}

{% hint style="warning" %}
Так как тэг `<Source>` всегда возвращает массив, то необходимо использовать тэг `<First>` (или любой другой способ), чтобы получить элемент массива, которой будет преобразовываться в строку и разбиваться по заданному разделителю.
{% endhint %}

{% hint style="warning" %}
Если в качестве значения тэга `<Source>` указано **не** **скалярное значение**, то будет генерироваться ошибка **TypeMismatch**.
{% endhint %}

<details>

<summary>Пример</summary>

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

Результат:

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

</details>

### ToDictionary <a href="#to_dictionary" id="to_dictionary"></a>

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

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

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

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

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

{% hint style="warning" %}
Если в качестве значения тэга `<Source>` указан **скаляр**, то будет генерироваться ошибка **TypeMismatch**.
{% endhint %}

<details>

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

```xml
<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" }
]
```

</details>

<details>

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

```xml
<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"}
]
```

</details>

### ToTable <a href="#to_table" id="to_table"></a>

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

```xml
<ToTable />
```

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

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

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+
```

</details>

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

<details>

<summary>Пример </summary>

```xml
<Array>
  <Source>2</Source>
  <ToTable />
</Array>
```

Результат:

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

</details>

### ToArray <a href="#to_array" id="to_array"></a>

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

```xml
<ToArray />
```

<details>

<summary>Пример</summary>

```xml
<Array>
  <Source>10</Source>
  <ToArray />
</Array>
```

Результат:

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

</details>

## Сортировка

### Order

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

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

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

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

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

{% hint style="warning" %}
Если в качестве значения тэга `<Source>` указан **скаляр**, то будет генерироваться ошибка **TypeMismatch**.
{% endhint %}

<details>

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

```xml
<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  |
+-----+----------+
```

</details>

<details>

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

```xml
<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  |
+-----+----------+
```

</details>

<details>

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

```xml
<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  |
+-----+-----+-----+-----+
```

</details>

### Sort

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

```xml
<Sort />
```

{% hint style="warning" %}
Если в качестве значения тэга `<Source>` указан **скаляр или матрица**, то будет генерироваться ошибка **TypeMismatch**.
{% endhint %}

<details>

<summary>Пример</summary>

```xml
<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  |
+-----+-----+-----+-----+
```

</details>


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://wfsys.gitbook.io/workflow-forms-syntax/workflow_forms/values/array.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
