← Cloudflare Pipelines / pipelines / sql-reference / scalar-functions

Funkce pro pole

Implementace skalárních funkcí Cloudflare Pipelines vychází z Apache DataFusion ↗ (přes Arroyo ↗) a tato dokumentace vychází z referenční dokumentace funkcí DataFusion.

`array_append`

Přidá prvek na konec pole.

array_append(array, element)

Argumenty

array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.
element: Prvek, který se má přidat na konec pole.

Příklad

> select array_append([1, 2, 3], 4);
+--------------------------------------+
| array_append(List([1,2,3]),Int64(4)) |
+--------------------------------------+
| [1, 2, 3, 4]                         |
+--------------------------------------+

Aliasy

array_push_back
list_append
list_push_back

`array_sort`

Seřadí pole.

array_sort(array, desc, nulls_first)

Argumenty

array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.
desc: Zda se má řadit sestupně (ASC nebo DESC).
nulls_first: Zda se mají hodnoty null řadit jako první (NULLS FIRST nebo NULLS LAST).

Příklad

> select array_sort([3, 1, 2]);
+-----------------------------+
| array_sort(List([3,1,2]))   |
+-----------------------------+
| [1, 2, 3]                   |
+-----------------------------+

Aliasy

list_sort

`array_resize`

Změní velikost seznamu tak, aby obsahoval počet prvků size. Nové prvky inicializuje hodnotou value, případně prázdnou hodnotou, pokud value není nastaveno.

array_resize(array, size, value)

Argumenty

array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.
velikost: Nová velikost daného pole.
hodnota: Definuje hodnotu nových prvků, nebo je prázdná, pokud hodnota není nastavena.

Příklad

> select array_resize([1, 2, 3], 5, 0);
+-------------------------------------+
| array_resize(List([1,2,3],5,0))     |
+-------------------------------------+
| [1, 2, 3, 0, 0]                     |
+-------------------------------------+

Aliasy

list_resize

`array_cat`

Alias pro array_concat.

`array_concat`

Spojí pole.

array_concat(array[, ..., array_n])

Argumenty

array: Výraz pole ke spojení. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.
array_n: Další sloupec pole nebo literál pole, který se má zřetězit.

Příklad

> select array_concat([1, 2], [3, 4], [5, 6]);
+---------------------------------------------------+
| array_concat(List([1,2]),List([3,4]),List([5,6])) |
+---------------------------------------------------+
| [1, 2, 3, 4, 5, 6]                                |
+---------------------------------------------------+

Aliasy

array_cat
list_cat
list_concat

`array_contains`

Alias pro array_has.

`array_has`

Vrátí true, pokud pole obsahuje daný prvek

array_has(array, element)

Argumenty

array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.
element: Skalární výraz nebo výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů polí.

Aliasy

list_has

`array_has_all`

Vrátí true, pokud se všechny prvky dílčího pole nacházejí v poli

array_has_all(array, sub-array)

Argumenty

array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.
dílčí pole: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.

Aliasy

list_has_all

`array_has_any`

Vrátí true, pokud se v obou polích nachází alespoň jeden shodný prvek

array_has_any(array, sub-array)

Argumenty

array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.
dílčí pole: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.

Aliasy

list_has_any

`array_dims`

Vrátí pole rozměrů daného pole.

array_dims(array)

Argumenty

array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.

Příklad

> select array_dims([[1, 2, 3], [4, 5, 6]]);
+---------------------------------+
| array_dims(List([1,2,3,4,5,6])) |
+---------------------------------+
| [2, 3]                          |
+---------------------------------+

Aliasy

list_dims

`array_distinct`

Vrátí jedinečné hodnoty z pole po odstranění duplicit.

array_distinct(array)

Argumenty

array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.

Příklad

> select array_distinct([1, 3, 2, 3, 1, 2, 4]);
+---------------------------------+
| array_distinct(List([1,2,3,4])) |
+---------------------------------+
| [1, 2, 3, 4]                    |
+---------------------------------+

Aliasy

list_distinct

`array_element`

Extrahuje prvek s indexem n z pole.

array_element(array, index)

Argumenty

array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.
index: Index, na kterém se má prvek z pole extrahovat.

Příklad

> select array_element([1, 2, 3, 4], 3);
+-----------------------------------------+
| array_element(List([1,2,3,4]),Int64(3)) |
+-----------------------------------------+
| 3                                       |
+-----------------------------------------+

Aliasy

array_extract
list_element
list_extract

`array_extract`

Alias pro array_element.

`array_fill`

Vrátí pole naplněné kopiemi zadané hodnoty.

ZASTARALÉ: použijte array_repeat místo toho!

array_fill(element, array)

Argumenty

array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.
element: Prvek, který se má zkopírovat do pole.

`flatten`

Převede pole polí na jednorozměrné pole

Platí pro libovolnou hloubku vnořených polí
Nemění pole, která jsou již jednorozměrná

Jednorozměrné pole obsahuje všechny prvky ze všech zdrojových polí.

Argumenty

array: Výraz pole Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.

flatten(array)

`array_indexof`

Alias pro array_position.

`array_intersect`

Vrátí pole prvků v průniku array1 a array2.

array_intersect(array1, array2)

Argumenty

array1: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.
array2: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.

Příklad

> select array_intersect([1, 2, 3, 4], [5, 6, 3, 4]);
+----------------------------------------------------+
| array_intersect([1, 2, 3, 4], [5, 6, 3, 4]);       |
+----------------------------------------------------+
| [3, 4]                                             |
+----------------------------------------------------+
> select array_intersect([1, 2, 3, 4], [5, 6, 7, 8]);
+----------------------------------------------------+
| array_intersect([1, 2, 3, 4], [5, 6, 7, 8]);       |
+----------------------------------------------------+
| []                                                 |
+----------------------------------------------------+

Aliasy

list_intersect

`array_join`

Alias pro array_to_string.

`array_length`

Vrátí délku dimenze pole.

array_length(array, dimension)

Argumenty

array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.
dimenze: Dimenze pole.

Příklad

> select array_length([1, 2, 3, 4, 5]);
+---------------------------------+
| array_length(List([1,2,3,4,5])) |
+---------------------------------+
| 5                               |
+---------------------------------+

Aliasy

list_length

`array_ndims`

Vrátí počet dimenzí pole.

array_ndims(array, element)

Argumenty

array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.

Příklad

> select array_ndims([[1, 2, 3], [4, 5, 6]]);
+----------------------------------+
| array_ndims(List([1,2,3,4,5,6])) |
+----------------------------------+
| 2                                |
+----------------------------------+

Aliasy

list_ndims

`array_prepend`

Přidá prvek na začátek pole.

array_prepend(element, array)

Argumenty

element: Prvek, který se má přidat na začátek pole.
array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.

Příklad

> select array_prepend(1, [2, 3, 4]);
+---------------------------------------+
| array_prepend(Int64(1),List([2,3,4])) |
+---------------------------------------+
| [1, 2, 3, 4]                          |
+---------------------------------------+

Aliasy

array_push_front
list_prepend
list_push_front

`array_pop_front`

Vrátí pole bez prvního prvku.

array_pop_front(array)

Argumenty

array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.

Příklad

> select array_pop_front([1, 2, 3]);
+-------------------------------+
| array_pop_front(List([1,2,3])) |
+-------------------------------+
| [2, 3]                        |
+-------------------------------+

Aliasy

list_pop_front

`array_pop_back`

Vrátí pole bez posledního prvku.

array_pop_back(array)

Argumenty

array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.

Příklad

> select array_pop_back([1, 2, 3]);
+-------------------------------+
| array_pop_back(List([1,2,3])) |
+-------------------------------+
| [1, 2]                        |
+-------------------------------+

Aliasy

list_pop_back

`array_position`

Vrátí pozici prvního výskytu zadaného prvku v poli.

array_position(array, element)
array_position(array, element, index)

Argumenty

array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.
element: Prvek, jehož pozice se má v poli vyhledat.
index: Index, od kterého se má začít hledat.

Příklad

> select array_position([1, 2, 2, 3, 1, 4], 2);
+----------------------------------------------+
| array_position(List([1,2,2,3,1,4]),Int64(2)) |
+----------------------------------------------+
| 2                                            |
+----------------------------------------------+

Aliasy

array_indexof
list_indexof
list_position

`array_positions`

Vyhledá prvek v poli a vrátí všechny jeho výskyty.

array_positions(array, element)

Argumenty

array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.
element: Prvek, jehož pozice se mají v poli vyhledat.

Příklad

> select array_positions([1, 2, 2, 3, 1, 4], 2);
+-----------------------------------------------+
| array_positions(List([1,2,2,3,1,4]),Int64(2)) |
+-----------------------------------------------+
| [2, 3]                                        |
+-----------------------------------------------+

Aliasy

list_positions

`array_push_back`

Alias pro array_append.

`array_push_front`

Alias pro array_prepend.

`array_repeat`

Vrátí pole obsahující prvek count krát.

array_repeat(element, count)

Argumenty

element: Výraz prvku. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.
count: Hodnota udávající, kolikrát se má prvek opakovat.

Příklad

> select array_repeat(1, 3);
+---------------------------------+
| array_repeat(Int64(1),Int64(3)) |
+---------------------------------+
| [1, 1, 1]                       |
+---------------------------------+

> select array_repeat([1, 2], 2);
+------------------------------------+
| array_repeat(List([1,2]),Int64(2)) |
+------------------------------------+
| [[1, 2], [1, 2]]                   |
+------------------------------------+

Aliasy

list_repeat

`array_remove`

Odstraní z pole první prvek rovný zadané hodnotě.

array_remove(array, element)

Argumenty

array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.
element: Prvek, který se má z pole odstranit.

Příklad

> select array_remove([1, 2, 2, 3, 2, 1, 4], 2);
+----------------------------------------------+
| array_remove(List([1,2,2,3,2,1,4]),Int64(2)) |
+----------------------------------------------+
| [1, 2, 3, 2, 1, 4]                           |
+----------------------------------------------+

Aliasy

list_remove

`array_remove_n`

Odstraní prvních max prvky pole, které se rovnají dané hodnotě.

array_remove_n(array, element, max)

Argumenty

array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.
element: Prvek, který se má z pole odstranit.
max: Počet prvních výskytů, které se mají odstranit.

Příklad

> select array_remove_n([1, 2, 2, 3, 2, 1, 4], 2, 2);
+---------------------------------------------------------+
| array_remove_n(List([1,2,2,3,2,1,4]),Int64(2),Int64(2)) |
+---------------------------------------------------------+
| [1, 3, 2, 1, 4]                                         |
+---------------------------------------------------------+

Aliasy

list_remove_n

`array_remove_all`

Odstraní z pole všechny prvky rovné zadané hodnotě.

array_remove_all(array, element)

Argumenty

array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.
element: Prvek, který se má z pole odstranit.

Příklad

> select array_remove_all([1, 2, 2, 3, 2, 1, 4], 2);
+--------------------------------------------------+
| array_remove_all(List([1,2,2,3,2,1,4]),Int64(2)) |
+--------------------------------------------------+
| [1, 3, 1, 4]                                     |
+--------------------------------------------------+

Aliasy

list_remove_all

`array_replace`

Nahradí první výskyt zadaného prvku jiným zadaným prvkem.

array_replace(array, from, to)

Argumenty

array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.
od: Počáteční prvek.
do: Poslední prvek.

Příklad

> select array_replace([1, 2, 2, 3, 2, 1, 4], 2, 5);
+--------------------------------------------------------+
| array_replace(List([1,2,2,3,2,1,4]),Int64(2),Int64(5)) |
+--------------------------------------------------------+
| [1, 5, 2, 3, 2, 1, 4]                                  |
+--------------------------------------------------------+

Aliasy

list_replace

`array_replace_n`

Nahradí první max výskytů zadaného prvku jiným zadaným prvkem.

array_replace_n(array, from, to, max)

Argumenty

array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.
od: Počáteční prvek.
do: Poslední prvek.
max: Počet prvních výskytů, které se mají nahradit.

Příklad

> select array_replace_n([1, 2, 2, 3, 2, 1, 4], 2, 5, 2);
+-------------------------------------------------------------------+
| array_replace_n(List([1,2,2,3,2,1,4]),Int64(2),Int64(5),Int64(2)) |
+-------------------------------------------------------------------+
| [1, 5, 5, 3, 2, 1, 4]                                             |
+-------------------------------------------------------------------+

Aliasy

list_replace_n

`array_replace_all`

Nahradí všechny výskyty zadaného prvku jiným zadaným prvkem.

array_replace_all(array, from, to)

Argumenty

array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.
od: Počáteční prvek.
do: Poslední prvek.

Příklad

> select array_replace_all([1, 2, 2, 3, 2, 1, 4], 2, 5);
+------------------------------------------------------------+
| array_replace_all(List([1,2,2,3,2,1,4]),Int64(2),Int64(5)) |
+------------------------------------------------------------+
| [1, 5, 5, 3, 5, 1, 4]                                      |
+------------------------------------------------------------+

Aliasy

list_replace_all

`array_reverse`

Vrátí pole s obráceným pořadím prvků.

array_reverse(array)

Argumenty

array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.

Příklad

> select array_reverse([1, 2, 3, 4]);
+------------------------------------------------------------+
| array_reverse(List([1, 2, 3, 4]))                          |
+------------------------------------------------------------+
| [4, 3, 2, 1]                                               |
+------------------------------------------------------------+

Aliasy

list_reverse

`array_slice`

Vrátí výřez pole na základě počáteční a koncové pozice indexované od 1.

array_slice(array, begin, end)

Argumenty

array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.
begin: Index prvního prvku. Pokud je záporný, počítá se od konce pole zpět.
end: Index posledního prvku. Pokud je záporný, počítá se od konce pole zpět.
stride: Krok výřezu pole. Výchozí hodnota je 1.

Příklad

> select array_slice([1, 2, 3, 4, 5, 6, 7, 8], 3, 6);
+--------------------------------------------------------+
| array_slice(List([1,2,3,4,5,6,7,8]),Int64(3),Int64(6)) |
+--------------------------------------------------------+
| [3, 4, 5, 6]                                           |
+--------------------------------------------------------+

Aliasy

list_slice

`array_to_string`

Převede každý prvek na jeho textovou podobu.

array_to_string(array, delimiter)

Argumenty

array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.
delimiter: Oddělovač prvků pole.

Příklad

> select array_to_string([[1, 2, 3, 4], [5, 6, 7, 8]], ',');
+----------------------------------------------------+
| array_to_string(List([1,2,3,4,5,6,7,8]),Utf8(",")) |
+----------------------------------------------------+
| 1,2,3,4,5,6,7,8                                    |
+----------------------------------------------------+

Aliasy

array_join
list_join
list_to_string

`array_union`

Vrátí pole prvků, které se vyskytují v obou polích (všechny prvky z obou polí) bez duplicit.

array_union(array1, array2)

Argumenty

array1: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.
array2: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.

Příklad

> select array_union([1, 2, 3, 4], [5, 6, 3, 4]);
+----------------------------------------------------+
| array_union([1, 2, 3, 4], [5, 6, 3, 4]);           |
+----------------------------------------------------+
| [1, 2, 3, 4, 5, 6]                                 |
+----------------------------------------------------+
> select array_union([1, 2, 3, 4], [5, 6, 7, 8]);
+----------------------------------------------------+
| array_union([1, 2, 3, 4], [5, 6, 7, 8]);           |
+----------------------------------------------------+
| [1, 2, 3, 4, 5, 6, 7, 8]                           |
+----------------------------------------------------+

Aliasy

list_union

`array_except`

Vrátí pole prvků, které se vyskytují v prvním poli, ale ne ve druhém.

array_except(array1, array2)

Argumenty

array1: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.
array2: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.

Příklad

> select array_except([1, 2, 3, 4], [5, 6, 3, 4]);
+----------------------------------------------------+
| array_except([1, 2, 3, 4], [5, 6, 3, 4]);           |
+----------------------------------------------------+
| [1, 2]                                 |
+----------------------------------------------------+
> select array_except([1, 2, 3, 4], [3, 4, 5, 6]);
+----------------------------------------------------+
| array_except([1, 2, 3, 4], [3, 4, 5, 6]);           |
+----------------------------------------------------+
| [1, 2]                                 |
+----------------------------------------------------+

Aliasy

list_except

`cardinality`

Vrátí celkový počet prvků v poli.

cardinality(array)

Argumenty

array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.

Příklad

> select cardinality([[1, 2, 3, 4], [5, 6, 7, 8]]);
+--------------------------------------+
| cardinality(List([1,2,3,4,5,6,7,8])) |
+--------------------------------------+
| 8                                    |
+--------------------------------------+

`empty`

Vrátí 1 pro prázdné pole nebo 0 pro neprázdné pole.

empty(array)

Argumenty

array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.

Příklad

> select empty([1]);
+------------------+
| empty(List([1])) |
+------------------+
| 0                |
+------------------+

Aliasy

array_empty,
list_empty

`generate_series`

Podobné funkci range, ale zahrnuje i horní mez.

generate_series(start, stop, step)

Argumenty

start: začátek rozsahu
end: konec rozsahu (včetně)
krok: zvýšení o krok (nesmí být 0)

Příklad

> select generate_series(1,3);
+------------------------------------+
| generate_series(Int64(1),Int64(3)) |
+------------------------------------+
| [1, 2, 3]                          |
+------------------------------------+

`list_append`

Alias pro array_append.

`list_cat`

Alias pro array_concat.

`list_concat`

Alias pro array_concat.

`list_dims`

Alias pro array_dims.

`list_distinct`

Alias pro array_dims.

`list_element`

Alias pro array_element.

`list_empty`

Alias pro empty.

`list_except`

Alias pro array_element.

`list_extract`

Alias pro array_element.

`list_has`

Alias pro array_has.

`list_has_all`

Alias pro array_has_all.

`list_has_any`

Alias pro array_has_any.

`list_indexof`

Alias pro array_position.

`list_intersect`

Alias pro array_position.

`list_join`

Alias pro array_to_string.

`list_length`

Alias pro array_length.

`list_ndims`

Alias pro array_ndims.

`list_prepend`

Alias pro array_prepend.

`list_pop_back`

Alias pro array_pop_back.

`list_pop_front`

Alias pro array_pop_front.

`list_position`

Alias pro array_position.

`list_positions`

Alias pro array_positions.

`list_push_back`

Alias pro array_append.

`list_push_front`

Alias pro array_prepend.

`list_repeat`

Alias pro array_repeat.

`list_resize`

Alias pro array_resize.

`list_remove`

Alias pro array_remove.

`list_remove_n`

Alias pro array_remove_n.

`list_remove_all`

Alias pro array_remove_all.

`list_replace`

Alias pro array_replace.

`list_replace_n`

Alias pro array_replace_n.

`list_replace_all`

Alias pro array_replace_all.

`list_reverse`

Alias pro array_reverse.

`list_slice`

Alias pro array_slice.

`list_sort`

Alias pro array_sort.

`list_to_string`

Alias pro array_to_string.

`list_union`

Alias pro array_union.

`make_array`

Vrátí Arrow array pomocí zadaných vstupních výrazů.

make_array(expression1[, ..., expression_n])

`array_empty`

Alias pro empty.

Argumenty

expression_n: Výraz, který se má zahrnout do výstupního pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace aritmetických nebo řetězcových operátorů.

Příklad

> select make_array(1, 2, 3, 4, 5);
+----------------------------------------------------------+
| make_array(Int64(1),Int64(2),Int64(3),Int64(4),Int64(5)) |
+----------------------------------------------------------+
| [1, 2, 3, 4, 5]                                          |
+----------------------------------------------------------+

Aliasy

make_list

`make_list`

Alias pro make_array.

`string_to_array`

Rozdělí řetězec na pole podřetězců podle oddělovače. Všechny podřetězce odpovídající volitelnému null_str argument jsou nahrazeny hodnotou NULL. SELECT string_to_array('abc##def', '##') nebo SELECT string_to_array('abc def', ' ', 'def')

starts_with(str, delimiter[, null_str])

Argumenty

str: Řetězcový výraz, který se má rozdělit.
delimiter: Řetězec oddělovače, podle kterého se dělí.
null_str: Hodnoty podřetězců, které se mají nahradit NULL

Aliasy

string_to_list

`string_to_list`

Alias pro string_to_array.

`trim_array`

Odstraní z pole posledních n prvků.

ZASTARALÉ: použijte array_slice místo toho!

trim_array(array, n)

Argumenty

array: Výraz pole. Může to být konstanta, sloupec nebo funkce a libovolná kombinace operátorů pro pole.
n: Prvek použitý k oříznutí pole.

`range`

Vrátí Arrow array mezi start a stop s krokem step. SELECT range(2, 10, 3) -> [2, 5, 8] nebo SELECT range(DATE '1992-09-01', DATE '1993-03-01', INTERVAL '1' MONTH);

Rozsah start..end obsahuje všechny hodnoty, pro které platí start <= x < end. Pokud je start >= end, je rozsah prázdný.

Krok nesmí být 0 (jinak by rozsah neměl smysl).

Upozorňujeme, že pokud je požadovaný rozsah číslo, přijímá jako parametry (stop), (start, stop) a (start, stop, step), ale pokud je požadovaný rozsah datum, musí jít o 3 parametry, které nejsou NULL. Například,

SELECT range(3);
SELECT range(1,5);
SELECT range(1,5,1);

jsou v číselných rozsazích povoleny

ale v rozsazích data pouze

SELECT range(DATE '1992-09-01', DATE '1993-03-01', INTERVAL '1' MONTH);

je povoleno, a

SELECT range(DATE '1992-09-01', DATE '1993-03-01', NULL);
SELECT range(NULL, DATE '1993-03-01', INTERVAL '1' MONTH);
SELECT range(DATE '1992-09-01', NULL, INTERVAL '1' MONTH);

nejsou povoleny

Argumenty

start: začátek rozsahu
end: konec rozsahu (nezahrnuto)
krok: zvýšení o krok (nesmí být 0)

Aliasy

generate_series