Triedenie

Funkcie ORDER zoraďujú hodnoty a vracajú novú kolekciu — buď zoradené hodnoty, alebo vo variantoch ORDERINDEX pôvodné pozície hodnôt (počítané od nuly) v zoradenom poradí.

Pravidlá spoločné pre všetkých osem funkcií:

• Berú 1 až 100 hodnôt alebo presne jednu kolekciu. Zdrojová kolekcia sa nemení.
• Hodnoty musia byť porovnateľné a jedného druhu — čísla, znaky, reťazce, datetime alebo timespan; miešanie čísel a reťazcov je chyba.
• Reťazce a znaky sa zoraďujú podľa kódu znaku, preto veľké písmená idú pred malými.
• Rovnaké hodnoty si zachovajú pôvodné poradie.
• Varianty STRICT dávajú neznáme hodnoty na začiatok, aj pri zostupných variantoch.
• Prázdna kolekcia je chyba: Collection is null or empty.

Príklad — najlacnejšia hodina zo zoznamu cien

VAR prices := {12.5, 8.1, 20.0, 9.9};
VAR cheapest := GETAT(ORDER(prices), 0);
# cheapest = 8.1
VAR cheapestHour := GETAT(ORDERINDEX(prices), 0);
# cheapestHour = 1

ORDER#

ORDER vráti hodnoty zoradené vzostupne, bez Null a NaN.

1
2

ORDER(value1, value2, ...)
ORDER(collection)

ORDER(3, 1, 2);
# Result: {1, 2, 3}
ORDER(3, NaN, 2, NaN);
# Result: {2, 3}
ORDER('Z', 'a', 'X');
# Result: {'X', 'Z', 'a'}
ORDER("str1", NULL, "STR2", "stR1");
# Result: {"STR2", "stR1", "str1"}
ORDER(NULL, TIMESPAN(0, 0, 0, 0, 100), TIMESPAN(0, 0, 0, 0, 99));
# Result: {TIMESPAN(0, 0, 0, 0, 99), TIMESPAN(0, 0, 0, 0, 100)}

ORDERSTRICT#

ORDERSTRICT vráti hodnoty zoradené vzostupne a Null a NaN ponechá na začiatku.

1
2

ORDERSTRICT(value1, value2, ...)
ORDERSTRICT(collection)

ORDERSTRICT(3, NaN, 2, NaN);
# Result: {NaN, NaN, 2, 3}
ORDERSTRICT("str1", "STR2", "stR1");
# Result: {"STR2", "stR1", "str1"}
ORDERSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99));
# Result: {NULL, TIMESPAN(0, 0, 0, 0, 99)}

ORDERDESC#

ORDERDESC vráti hodnoty zoradené zostupne, bez Null a NaN.

1
2

ORDERDESC(value1, value2, ...)
ORDERDESC(collection)

ORDERDESC(3, 1, 2);
# Result: {3, 2, 1}
ORDERDESC(3, NaN, 2, NaN);
# Result: {3, 2}
ORDERDESC('Z', 'a', 'X');
# Result: {'a', 'Z', 'X'}
ORDERDESC("str1", NULL, "STR2", "stR1");
# Result: {"str1", "stR1", "STR2"}

ORDERDESCSTRICT#

ORDERDESCSTRICT vráti hodnoty zoradené zostupne a Null a NaN ponechá na začiatku.

1
2

ORDERDESCSTRICT(value1, value2, ...)
ORDERDESCSTRICT(collection)

ORDERDESCSTRICT(3, NaN, 2, NaN);
# Result: {NaN, NaN, 3, 2}
ORDERDESCSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99), TIMESPAN(0, 0, 0, 0, 100));
# Result: {NULL, TIMESPAN(0, 0, 0, 0, 100), TIMESPAN(0, 0, 0, 0, 99)}

ORDERINDEX#

ORDERINDEX vráti pozície hodnôt vo vzostupnom poradí hodnôt, bez pozícií Null a NaN.

1
2

ORDERINDEX(value1, value2, ...)
ORDERINDEX(collection)

Návratová hodnota — collection<int> pozícií vo vstupe, počítaných od nuly. Prvý prvok je pozícia najmenšej hodnoty.

ORDERINDEX(3, 1, 2);
# Result: {1, 2, 0}
ORDERINDEX(3, NaN, 2, NaN);
# Result: {2, 0}
ORDERINDEX("str1", NULL, "STR2", "stR1");
# Result: {2, 3, 0}

ORDERINDEXSTRICT#

ORDERINDEXSTRICT vráti pozície hodnôt vo vzostupnom poradí hodnôt, pričom pozície Null a NaN sú na začiatku.

1
2

ORDERINDEXSTRICT(value1, value2, ...)
ORDERINDEXSTRICT(collection)

ORDERINDEXSTRICT(3, 1, 2);
# Result: {1, 2, 0}
ORDERINDEXSTRICT(3, NaN, 2, NaN);
# Result: {1, 3, 2, 0}
ORDERINDEXSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99));
# Result: {0, 1}

ORDERINDEXDESC#

ORDERINDEXDESC vráti pozície hodnôt v zostupnom poradí hodnôt, bez pozícií Null a NaN.

1
2

ORDERINDEXDESC(value1, value2, ...)
ORDERINDEXDESC(collection)

ORDERINDEXDESC(3, 1, 2);
# Result: {0, 2, 1}
ORDERINDEXDESC(3, NaN, 2);
# Result: {0, 2}
ORDERINDEXDESC("str1", NULL, "STR2", "stR1");
# Result: {0, 3, 2}

ORDERINDEXDESCSTRICT#

ORDERINDEXDESCSTRICT vráti pozície hodnôt v zostupnom poradí hodnôt, pričom pozície Null a NaN sú na začiatku.

1
2

ORDERINDEXDESCSTRICT(value1, value2, ...)
ORDERINDEXDESCSTRICT(collection)

ORDERINDEXDESCSTRICT(3, 1, 2);
# Result: {0, 2, 1}
ORDERINDEXDESCSTRICT(3, NaN, 2, NaN);
# Result: {1, 3, 0, 2}
ORDERINDEXDESCSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99));
# Result: {0, 1}