Třídění

Existuje několik variant ORDER:
Vzestupně – ORDER, ORDERSTRICT – ORDERINDEX, ORDERINDEXSTRICT
Sestupně – ORDERDESC, ORDERDESCSTRICT – ORDERINDEXDESC, ORDERINDEXDESCSTRICT

ORDER#

Funkce ORDER třídí poskytnuté vstupní hodnoty vzestupně a vrací je v nové kolekci. Přijímá n hodnot (až 100 argumentů) nebo jednu kolekci. Hodnoty nemusí být numerické, musí však být porovnatelné (např. čísla, TIMESPAN, DATETIME, řetězce). Smíšené typy (např. čísla a řetězce) nejsou povoleny. Hodnoty NaN a NULL jsou ignorovány a ve vrácené kolekci se nevyskytují.

ORDER( n1, n2, n3 , … )
ORDER( collection )

Příklady:

ORDER(3, 1, 2)				= {1, 2, 3}
ORDER(1)					= {1}
ORDER(3, NaN, 2, NaN)		= {2, 3}
ORDER(NaN)					= {}
ORDER('Z', 'a', 'X')				= {'X', 'Z', 'a'}
ORDER(“str1”, “STR2”, “stR1”) 		= {"STR2", "stR1", "str1"}
ORDER(“str1”, NULL, “STR2”, “stR1”) = {"STR2", "stR1", "str1"}

ORDER(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99))	= {TIMESPAN(0,0,0,0,99), TIMESPAN(0,0,0,0,100)}
ORDER(NULL, TIMESPAN(0,0,0,0,99))					= {TIMESPAN(0,0,0,0,99)}

ORDERINDEX#

Funkce ORDERINDEX třídí poskytnuté vstupní hodnoty vzestupně podobně jako ORDER. Namísto vrácení seřazených hodnot vrací kolekci indexů, které určují polohy původních hodnot v seřazeném pořadí. Přijímá n hodnot (až 100 argumentů) nebo jednu kolekci. Hodnoty nemusí být numerické, musí však být porovnatelné. Smíšené typy nejsou povoleny. Hodnoty NaN a NULL jsou ignorovány a ve vrácené kolekci se nevyskytují.

ORDERINDEX( n1, n2, n3 , … )
ORDERINDEX( collection )

Příklady:

ORDERINDEX(3, 1, 2)				= {1, 2, 0}
ORDERINDEX(1)					= {0}
ORDERINDEX(3, NaN, 2, NaN)		= {2, 0}
ORDERINDEX(NaN)					= {}
ORDERINDEX('Z', 'a', 'X')				= {2, 0, 1}
ORDERINDEX(“str1”, “STR2”, “stR1”) 		= {1, 2, 0}
ORDERINDEX(“str1”, NULL, “STR2”, “stR1”) = {2, 3, 0}

ORDERINDEX(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99))	= {1, 0}
ORDERINDEX(NULL, TIMESPAN(0,0,0,0,99))					= {1}

ORDERSTRICT#

Funkce ORDERSTRICT třídí poskytnuté vstupní hodnoty vzestupně a vrací je v nové kolekci. Přijímá n hodnot (až 100 argumentů) nebo jednu kolekci. Hodnoty nemusí být numerické, ale musí být porovnatelné. Smíšené typy nejsou povoleny. Hodnoty NaN a NULL jsou zahrnuty a vždy se řadí na první místa výsledku.

ORDERSTRICT( n1, n2, n3 , … )
ORDERSTRICT( collection )

Příklady:

ORDERSTRICT(3, 1, 2)			= {1, 2, 3}
ORDERSTRICT(1)					= {1}
ORDERSTRICT(3, NaN, 2, NaN)		= {NaN, NaN, 2, 3}
ORDERSTRICT(NaN)				= {NaN}
ORDERSTRICT('Z', 'a', 'X')		= {'X', 'Z', 'a'}
ORDERSTRICT(“str1”, “STR2”, “stR1”) 		= {"STR2", "stR1", "str1"}
ORDERSTRICT(“str1”, NULL, “STR2”, “stR1”)	= {NULL, "STR2", "stR1", "str1"}

ORDERSTRICT(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99))	= {TIMESPAN(0,0,0,0,99), TIMESPAN(0,0,0,0,100)}
ORDERSTRICT(NULL, TIMESPAN(0,0,0,0,99))					= {NULL, TIMESPAN(0,0,0,0,99)}

ORDERINDEXSTRICT#

Funkce ORDERINDEXSTRICT třídí poskytnuté vstupní hodnoty vzestupně, podobně jako ORDERSTRICT. Místo vrácení seřazených hodnot vrací kolekci indexů určujících polohy původních hodnot v seřazeném pořadí. Přijímá n hodnot (až 100 argumentů) nebo jednu kolekci. Hodnoty nemusí být numerické, ale musí být porovnatelné. Smíšené typy nejsou povoleny. Hodnoty NaN a NULL jsou zahrnuty a vždy se řadí na první místa výsledku.

ORDERINDEXSTRICT( n1, n2, n3 , … )
ORDERINDEXSTRICT( collection )

Příklady:

ORDERINDEXSTRICT(3, 1, 2)				= {1, 2, 0}
ORDERINDEXSTRICT(1)						= {0}
ORDERINDEXSTRICT(3, NaN, 2, NaN)		= {1, 3, 2, 0}
ORDERINDEXSTRICT(NaN)					= {0}
ORDERINDEXSTRICT('Z', 'a', 'X')			= {2, 0, 1}
ORDERINDEXSTRICT(“str1”, “STR2”, “stR1”)		= {1, 2, 0}
ORDERINDEXSTRICT(“str1”, NULL, “STR2”, “stR1”) 	= {1, 2, 3, 0}

ORDERINDEXSTRICT(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99))	= {1, 0}
ORDERINDEXSTRICT(NULL, TIMESPAN(0,0,0,0,99))						= {0, 1}

ORDERDESC#

Funkce ORDERDESC třídí poskytnuté vstupní hodnoty sestupně a vrací je v nové kolekci. Hodnoty nemusí být numerické, ale musí být porovnatelné. Smíšené typy nejsou povoleny. Hodnoty NaN a NULL jsou ignorovány a ve vrácené kolekci se nevyskytují.

ORDERDESC( n1, n2, n3 , … )
ORDERDESC( collection )

Příklady:

ORDERDESC(3, 1, 2)					= {3, 2, 1}
ORDERDESC(1)						= {1}
ORDERDESC(3, NaN, 2, NaN)			= {3, 2}
ORDERDESC(NaN)						= {}
ORDERDESC('Z', 'a', 'X')			= {'a', 'Z', 'X'}
ORDERDESC(“str1”, “STR2”, “stR1”) 	= {"str1", "stR1", "STR2"}
ORDERDESC(“str1”, NULL, “STR2”, “stR1”) 	= {"str1", "stR1", "STR2"}

ORDERDESC(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99))	= {TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)}
ORDERDESC(NULL, TIMESPAN(0,0,0,0,99))					= {TIMESPAN(0,0,0,0,99)}

ORDERINDEXDESC#

Funkce ORDERINDEXDESC třídí poskytnuté vstupní hodnoty sestupně, podobně jako ORDERDESC. Místo vrácení seřazených hodnot vrací kolekci indexů určujících polohy původních hodnot v seřazeném pořadí. Hodnoty nemusí být numerické, ale musí být porovnatelné. Smíšené typy nejsou povoleny. Hodnoty NaN a NULL jsou ignorovány a ve vrácené kolekci se nevyskytují.

ORDERINDEXDESC( n1, n2, n3 , … )
ORDERINDEXDESC( collection )

Příklady:

ORDERINDEXDESC(3, 1, 2)				= {0, 2, 1}
ORDERINDEXDESC(1)					= {0}
ORDERINDEXDESC(3, NaN, 2)			= {0, 2}
ORDERINDEXDESC(NaN)					= {}
ORDERINDEXDESC('Z', 'a', 'X')			= {1, 0, 2}
ORDERINDEXDESC(“str1”, “STR2”, “stR1”) 	= {0, 2, 1}
ORDERINDEXDESC(“str1”, NULL, “STR2”, “stR1”) 	= {0, 3, 2}

ORDERINDEXDESC(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99))	= {0, 1}
ORDERINDEXDESC(NULL, TIMESPAN(0,0,0,0,99))					= {1}

ORDERDESCSTRICT#

Funkce ORDERDESCSTRICT třídí poskytnuté vstupní hodnoty sestupně a vrací je v nové kolekci. Přijímá n hodnot (až 100 argumentů) nebo jednu kolekci. Hodnoty nemusí být numerické, ale musí být porovnatelné. Smíšené typy nejsou povoleny. Hodnoty NaN a NULL jsou zahrnuty a vždy se řadí na první místa výsledku.

ORDERDESCSTRICT( n1, n2, n3 , … )
ORDERDESCSTRICT( collection )

Příklady:

ORDERDESCSTRICT(3, 1, 2)			= {3, 2, 1}
ORDERDESCSTRICT(1)					= {1}
ORDERDESCSTRICT(3, NaN, 2, NaN)		= {NaN, NaN, 3, 2}
ORDERDESCSTRICT(NaN)				= {NaN}
ORDERDESCSTRICT('Z', 'a', 'X')					= {'a', 'Z', 'X'}
ORDERDESCSTRICT(“str1”, “STR2”, “stR1”) 		= {"str1", "stR1", "STR2"}
ORDERDESCSTRICT(“str1”, NULL, “STR2”, “stR1”) 	= {NULL, "str1", "stR1", "STR2"}

ORDERDESCSTRICT(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99))	= {TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)}
ORDERDESCSTRICT(NULL, TIMESPAN(0,0,0,0,99))					= {NULL, TIMESPAN(0,0,0,0,99)}

ORDERINDEXDESCSTRICT#

Funkce ORDERINDEXDESCSTRICT třídí poskytnuté vstupní hodnoty sestupně, podobně jako ORDERDESCSTRICT. Místo vrácení seřazených hodnot vrací kolekci indexů určujících polohy původních hodnot v seřazeném pořadí. Hodnoty nemusí být numerické, ale musí být porovnatelné. Smíšené typy nejsou povoleny. Hodnoty NaN a NULL jsou zahrnuty a vždy se řadí na první místa výsledku.

ORDERINDEXDESCSTRICT( n1, n2, n3 , … )
ORDERINDEXDESCSTRICT( collection )

Příklady:

ORDERINDEXDESCSTRICT(3, 1, 2)				= {0, 2, 1}
ORDERINDEXDESCSTRICT(1)						= {0}
ORDERINDEXDESCSTRICT(3, NaN, 2, NaN)		= {1, 3, 0, 2}
ORDERINDEXDESCSTRICT(NaN)					= {0}
ORDERINDEXDESCSTRICT('Z', 'a', 'X')			= {1, 0, 2}
ORDERINDEXDESCSTRICT(“str1”, “STR2”, “stR1”)		= {0, 2, 1}
ORDERINDEXDESCSTRICT(“str1”, NULL, “STR2”, “stR1”) 	= {1, 0, 3, 2}

ORDERINDEXDESCSTRICT(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99))	= {0, 1}
ORDERINDEXDESCSTRICT(NULL, TIMESPAN(0,0,0,0,99))						= {0, 1}