Operatoren

Eine Liste der Operatoren, die Sie in benutzerdefinierten oder berechneten Ausdrücken verwenden können.


Operator	Beschreibung
`- Arg1`	Negiert das Argument. Das Argument und das Ergebnis sind `reelle Zahlen`.
`Arg1 + Arg2`	Addiert die beiden Argumente. Informationen zur Verkettung von `Zeichenfolgen` finden Sie im Abschnitt über den Operator `&`.
`Arg1 - Arg2`	Subtrahiert Arg2 von Arg1.
`Arg1 * Arg2`	Multipliziert die beiden Argumente. Die Argumente und das Ergebnis sind `reelle Zahlen` oder `Dezimalzahlen`.
`Arg1 / Arg2`	Dividiert Arg1 durch Arg2. Die Argumente und das Ergebnis sind `reelle Zahlen` oder `Dezimalzahlen`. Eine Division durch null führt zu einem ungültigen Wert. Beispiele: 7/2 → 3.5 0/0 → `(Empty)` -1/0 → `(Empty)`
`Arg1 & Arg2`	Hängt Arg2 an das Ende von Arg1 an. Die Argumente können von jedem beliebigen Typ sein, werden jedoch in Zeichenfolgen konvertiert. Das Ergebnis ist eine `Zeichenfolge`. Weitere Informationen finden Sie unter der Funktion `Verketten`. Beispiele: `"April " & (20+1) & "st"` → "April 21st" `null & "Ape"` → `(Empty)`
`Arg1 % Arg2`	Gibt den Rest der Division von Arg1 durch Arg2 zurück. Die Argumente und das Ergebnis sind `reelle Zahlen` oder `Dezimalzahlen`. Ungültige Werte werden an die Ergebnisspalte propagiert. Beispiel: `3,5 % 2,5` → 1.00
`Arg1 != Arg2`	Gibt 'true' (wahr) zurück, wenn `Arg1` ungleich `Arg2` ist. Beispiele: `If( 1 != 2, true, false )` `Case when 2 != 2 then true else false end`
`Arg1^Arg2`	Gibt Arg1 hoch Arg2 zurück. Beispiel: `2.5^3` `[Wertspalte]^2`
`Arg1 < Arg2`	Gibt `true` zurück, wenn `Arg1` kleiner als Arg2 ist. Die Argumente können von jedem beliebigen Typ sein, müssen aber beide denselben Typ aufweisen. Das Ergebnis ist ein `boolescher Wert`. Wenn ein Argument ungültig ist, ist das Ergebnis ebenfalls ungültig. Die Funktion ist zum Vergleich normaler Zahlen definiert. Andere Kombinationen führen zu ungültigen Werten. Beispiele: `If( 1 < 2, "true", "false" )` → `true` `Case when 2 < 1 then "true" else "false" end` → `false` `If(1<null, "true", "false")` → `(Empty)` `If(1 < 1/0, "true", "false")` → `(Empty)`
`Arg1 > Arg2`	Gibt `true` zurück, wenn `Arg1` größer als Arg2 ist. Die Argumente sind `reelle Zahlen`, und das Ergebnis ist ein `boolescher Wert`. Informationen zur Definition gültiger Argumente finden Sie im Abschnitt über den Operator `<`.
`Arg1 <= Arg2`	Gibt `true` zurück, wenn Arg1 kleiner oder gleich Arg2 ist. Die Argumente sind `reelle Zahlen`, und das Ergebnis ist ein `boolescher Wert`. Informationen zur Definition gültiger Argumente finden Sie im Abschnitt über den Operator `<`.
`Arg1 >= Arg2`	Gibt `true` zurück, wenn Arg1 größer oder gleich Arg2 ist. Die Argumente sind `reelle Zahlen`, und das Ergebnis ist ein `boolescher Wert`. Informationen zur Definition gültiger Argumente finden Sie im Abschnitt über den Operator `<`.
`Arg1 = Arg2`	Gibt 'true' (wahr) zurück, wenn Arg1 gleich Arg2 ist. Die Argumente können von jedem beliebigen Typ sein, müssen aber beide denselben Typ aufweisen. Das Ergebnis ist ein `boolescher Wert`. Wenn ein Argument null ist, ist das Ergebnis ebenfalls null. Informationen zur Definition gültiger Argumente bei `reellen Zahlen` finden Sie im Abschnitt über den Operator `<`. Beispiele: `If(1 = 2, "true", "false" )` → `alse` `Case when 2 = 2 then "true" else "false" end` → `rue` `If("Hello" = "hello", "true", "false" )` → `alse` `If("" = null, "true", "false" )` `→ (Empty)` `If(null = null, "true", "false" )` → `(Empty)`
`Arg1 <=> Arg2`	Gibt 'true' (wahr) zurück, wenn das erste Argument dem zweiten Argument entspricht oder wenn beide Argumente null sind. Die Argumente können von jedem beliebigen Typ sein, müssen aber beide denselben Typ aufweisen. Das Ergebnis ist ein boolescher Wert. Beispiel: `Case when [Column1] <=> [Column2] then 'match' else 'no match' end`
`Arg1 <> Arg2`	Gibt `true` zurück, wenn Arg1 ungleich Arg2 ist. Die Argumente können von jedem beliebigen Typ sein, müssen aber beide denselben Typ aufweisen. Das Ergebnis ist ein `boolescher Wert`. Wenn ein Argument ungültig ist, ist das Ergebnis ebenfalls ungültig. Informationen zur Definition gültiger Argumente bei `reellen Zahlen` finden Sie im Abschnitt über den Operator `<`.
`Arg1 ~= Arg2`	Operator, der Teil einer `IF`- oder `CASE`-Anweisung sein kann. Die Argumente können von jedem beliebigen Typ sein, werden jedoch als Zeichenfolgenspalten behandelt. Gibt `true` zurück, wenn die Zeichenfolge für den regulären Ausdruck Arg2 mit der Zeichenfolge Arg1 übereinstimmt. Einige Zeichen wie der umgekehrte Schrägstrich „`\`“ müssen für das Arbeiten mit berechneten Spalten maskiert werden. Weitere Informationen finden Sie in der Literatur zu regulären Ausdruckssprachelementen, beispielsweise bei MSDN. Beispiele: `If( "aab" ~= "a+" , "true", "false" )` → `true` `Case when "aba" ~= ".a+$" then "true" else "false" end` → `true`
`And(Arg1, ...)`	Operator, der Teil einer `IF`- oder `CASE`-Anweisung sein kann. Er besitzt zwei boolesche Ausdrücke als Argumente und gibt `true` zurück, wenn beide Ausdrücke wahr sind. Beispiele: `If( 1 < 2 and 2 < 3, "true", "false" )` `Case when false and true then "true" else "false" end`
`Not(Arg1)`	Operator, der Teil einer `IF`- oder `CASE`-Anweisung sein kann. Hierbei wird der als Argument angegebene boolesche Ausdruck negiert. Beispiele: `If( not 1 < 2, "true", "false" )` `Case when not true then "true" else "false" end`
`Or(Arg1, ...)`	Operator, der Teil einer `IF`- oder `CASE`-Anweisung sein kann. Sie besitzt zwei boolesche Ausdrücke als Argumente und gibt `true` zurück, wenn einer der Ausdrücke wahr ist. Beispiele: `If( 1 < 2 or 2 < 3, "true", "false" )` `Case when false or true then "true" else "false" end`
`Xor(Arg1, ...)`	Kann Teil einer `IF`- oder `CASE`-Anweisung sein. Sie besitzt zwei boolesche Ausdrücke als Argumente und gibt `true` zurück, wenn genau einer der Ausdrücke wahr ist. Beispiele: `If(1 < 2 xor 2 < 3, true, false)` `Case when [A]>10 xor [B]>5 then 1 else 0 end`