Rendezés

Az ORDER függvények rendezik az értékeket, és új gyűjteményt adnak vissza — vagy a rendezett értékeket, vagy az ORDERINDEX változatokban az értékek eredeti, nullától kezdődő pozícióit rendezett sorrendben.

Mind a nyolc függvényre érvényes szabályok:

• 1–100 értéket fogadnak, vagy pontosan egy gyűjteményt. A forrásgyűjtemény nem változik.
• Az értékeknek összehasonlíthatónak és egyfajtának kell lenniük — számok, karakterek, szövegek, datetime vagy timespan; számok és szövegek keverése hibát okoz.
• A szövegek és a karakterek rendezése karakterkód szerint történik, így a nagybetűk a kisbetűk elé kerülnek.
• Az egyenlő értékek megtartják eredeti sorrendjüket.
• A STRICT változatok az ismeretlen értékeket az elejére teszik, a csökkenő változatokban is.
• Az üres gyűjtemény hibát okoz: Collection is null or empty.

Példa — a legolcsóbb óra egy árlistából

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#

Az ORDER az értékeket növekvő sorrendbe rendezve adja vissza, Null és NaN nélkül.

1
2

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

# számok, növekvő sorrendben
ORDER(3, 1, 2);
# Result: {1, 2, 3}
# a NaN értékek kimaradnak
ORDER(3, NaN, 2, NaN);
# Result: {2, 3}
# karakterek karakterkód szerint
ORDER('Z', 'a', 'X');
# Result: {'X', 'Z', 'a'}
# szövegek karakterkód szerint, a NULL kimarad
ORDER("str1", NULL, "STR2", "stR1");
# Result: {"STR2", "stR1", "str1"}
# időtartamok, a NULL kimarad
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#

Az ORDERSTRICT az értékeket növekvő sorrendbe rendezve adja vissza, a Null és a NaN értékeket az elején megtartja.

1
2

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

# a NaN értékek elöl maradnak
ORDERSTRICT(3, NaN, 2, NaN);
# Result: {NaN, NaN, 2, 3}
# szövegek karakterkód szerint
ORDERSTRICT("str1", "STR2", "stR1");
# Result: {"STR2", "stR1", "str1"}
# a NULL elöl marad
ORDERSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99));
# Result: {NULL, TIMESPAN(0, 0, 0, 0, 99)}

ORDERDESC#

Az ORDERDESC az értékeket csökkenő sorrendbe rendezve adja vissza, Null és NaN nélkül.

1
2

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

# számok, csökkenő sorrendben
ORDERDESC(3, 1, 2);
# Result: {3, 2, 1}
# a NaN értékek kimaradnak
ORDERDESC(3, NaN, 2, NaN);
# Result: {3, 2}
# karakterek csökkenően kód szerint
ORDERDESC('Z', 'a', 'X');
# Result: {'a', 'Z', 'X'}
# szövegek csökkenően, a NULL kimarad
ORDERDESC("str1", NULL, "STR2", "stR1");
# Result: {"str1", "stR1", "STR2"}

ORDERDESCSTRICT#

Az ORDERDESCSTRICT az értékeket csökkenő sorrendbe rendezve adja vissza, a Null és a NaN értékeket az elején megtartja.

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#

Az ORDERINDEX az értékek pozícióit adja vissza az értékek növekvő sorrendjében, a Null és a NaN pozíciói nélkül.

1
2

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

Visszatérési érték — a bemeneten belüli, nullától kezdődő pozíciók collection<int> gyűjteménye. Az első elem a legkisebb érték pozíciója.

# a számok pozíciói, növekvően
ORDERINDEX(3, 1, 2);
# Result: {1, 2, 0}
# a NaN pozíciói kimaradnak
ORDERINDEX(3, NaN, 2, NaN);
# Result: {2, 0}
# a szövegek pozíciói, a NULL kimarad
ORDERINDEX("str1", NULL, "STR2", "stR1");
# Result: {2, 3, 0}

ORDERINDEXSTRICT#

Az ORDERINDEXSTRICT az értékek pozícióit adja vissza az értékek növekvő sorrendjében, elöl a Null és a NaN pozícióival.

1
2

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

# a számok pozíciói, növekvően
ORDERINDEXSTRICT(3, 1, 2);
# Result: {1, 2, 0}
# a NaN pozíciói elöl vannak
ORDERINDEXSTRICT(3, NaN, 2, NaN);
# Result: {1, 3, 2, 0}
# a NULL pozíciója elöl van
ORDERINDEXSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99));
# Result: {0, 1}

ORDERINDEXDESC#

Az ORDERINDEXDESC az értékek pozícióit adja vissza az értékek csökkenő sorrendjében, a Null és a NaN pozíciói nélkül.

1
2

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

# a számok pozíciói, csökkenően
ORDERINDEXDESC(3, 1, 2);
# Result: {0, 2, 1}
# a NaN pozíciói kimaradnak
ORDERINDEXDESC(3, NaN, 2);
# Result: {0, 2}
# a szövegek pozíciói, a NULL kimarad
ORDERINDEXDESC("str1", NULL, "STR2", "stR1");
# Result: {0, 3, 2}

ORDERINDEXDESCSTRICT#

Az ORDERINDEXDESCSTRICT az értékek pozícióit adja vissza az értékek csökkenő sorrendjében, elöl a Null és a NaN pozícióival.

1
2

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

# a számok pozíciói, csökkenően
ORDERINDEXDESCSTRICT(3, 1, 2);
# Result: {0, 2, 1}
# a NaN pozíciói elöl vannak
ORDERINDEXDESCSTRICT(3, NaN, 2, NaN);
# Result: {1, 3, 0, 2}
# a NULL pozíciója elöl van
ORDERINDEXDESCSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99));
# Result: {0, 1}

Lásd még — Szöveg és gyűjtemények, Matematikai függvények.