Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # Funktionen In diesem Abschnitt finden Sie eine Liste der in Amazon Quick verfügbaren Funktionen. Eine nach Kategorien sortierte Liste der Funktionen mit kurzen Definitionen finden Sie unter [Funktionen nach Kategorien](https://docs.aws.amazon.com/quicksight/latest/user/functions-by-category.html). **Topics** + [addDateTime](addDateTime-function.md) + [addWorkDays](addWorkDays-function.md) + [Abs](abs-function.md) + [Ceil](ceil-function.md) + [Coalesce](coalesce-function.md) + [Concat](concat-function.md) + [contains](contains-function.md) + [decimalToInt](decimalToInt-function.md) + [dateDiff](dateDiff-function.md) + [endsWith](endsWith-function.md) + [epochDate](epochDate-function.md) + [Exp](exp-function.md) + [Extract](extract-function.md) + [Floor](floor-function.md) + [formatDate](formatDate-function.md) + [Ifelse](ifelse-function.md) + [in](in-function.md) + [intToDecimal](intToDecimal-function.md) + [isNotNull](isNotNull-function.md) + [isNull](isNull-function.md) + [isWorkDay](isWorkDay-function.md) + [Left](left-function.md) + [Locate](locate-function.md) + [Log](log-function.md) + [Ln](ln-function.md) + [Ltrim](ltrim-function.md) + [Mod](mod-function.md) + [netWorkDays](netWorkDays-function.md) + [Now](now-function.md) + [notIn](notIn-function.md) + [nullIf](nullIf-function.md) + [parseDate](parseDate-function.md) + [parseDecimal](parseDecimal-function.md) + [parseInt](parseInt-function.md) + [parseJson](parseJson-function.md) + [Replace](replace-function.md) + [Right](right-function.md) + [Round](round-function.md) + [Rtrim](rtrim-function.md) + [Split](split-function.md) + [Sqrt](sqrt-function.md) + [startsWith](startsWith-function.md) + [Strlen](strlen-function.md) + [Substring](substring-function.md) + [switch](switch-function.md) + [toLower](toLower-function.md) + [toString](toString-function.md) + [toUpper](toUpper-function.md) + [trim](trim-function.md) + [truncDate](truncDate-function.md) # addDateTime `addDateTime` fügt eine Zeiteinheit von einem Datums-/Uhrzeit-Wert hinzu oder zieht diese ab. Beispielsweise gibt `addDateTime(2,'YYYY',parseDate('02-JUL-2018', 'dd-MMM-yyyy') )` `02-JUL-2020` zurück. Mit dieser Funktion können Sie eine Datumsberechnung für Ihre Datums- und Zeitdaten durchführen. ## Syntax ``` addDateTime(amount, period, datetime) ``` ## Argumente *Betrag* Ein positiver oder negativer Ganzzahlwert, der die Zeit angibt, die Sie vom angegebenen Datumsfeld addieren oder subtrahieren möchten. *Zeitraum* Ein positiver oder negativer Wert, der die Zeit angibt, die Sie vom angegebenen Datumsfeld addieren oder subtrahieren möchten. Folgende Zeiträume werden unterstützt: + YYYY: Gibt den Jahresteil des Datums zurück. + Q: Gibt das Quartal zurück, in das das Datum fällt (1-4). + MM: Gibt den Monatsteil des Datums zurück. + DD: Gibt den Tagesteil des Datums zurück. + WK: Gibt den Wochenteil des Datums zurück. Die Woche beginnt am Sonntag in Amazon Quick. + HH: Gibt den Stundenteil des Datums zurück. + MI: Gibt den Minutenteil des Datums zurück. + SS: Gibt den Sekundenteil des Datums zurück. + SS: Gibt den Sekundenteil des Datums zurück. *datetime* Das Datum oder die Uhrzeit, für das Sie die Datumsberechnung durchführen möchten. ## Rückgabetyp DateTime ## Beispiel Nehmen wir an, Sie haben ein Feld mit dem Namen `purchase_date`, das die folgenden Werte hat. ``` 2018 May 13 13:24 2017 Jan 31 23:06 2016 Dec 28 06:45 ``` Mit den folgenden Berechnungen modifiziert `addDateTime` die Werte wie folgt. ``` addDateTime(-2, 'YYYY', purchaseDate) 2016 May 13 13:24 2015 Jan 31 23:06 2014 Dec 28 06:45 addDateTime(4, 'DD', purchaseDate) 2018 May 17 13:24 2017 Feb 4 23:06 2017 Jan 1 06:45 addDateTime(20, 'MI', purchaseDate) 2018 May 13 13:44 2017 Jan 31 23:26 2016 Dec 28 07:05 ``` # addWorkDays `addWorkDays` addiert oder subtrahiert eine bestimmte Anzahl von Arbeitstagen zu einem bestimmten Datumswert. Die Funktion gibt ein Datum für einen Arbeitstag zurück, das auf einen bestimmten Werktag nach oder vor einem bestimmten Eingabedatumswert liegt. ## Syntax ``` addWorkDays(initDate, numWorkDays) ``` ## Argumente *initDate* Ein gültiges Datum ungleich NULL, das als Startdatum für die Berechnung dient. + **Datensatzfeld** — Jedes `date`-Feld aus dem Datensatz, dem Sie diese Funktion hinzufügen. + **Datumsfunktion** — Jede Datumsausgabe aus einer anderen `date`-Funktion, wie z. B. `parseDate`, `epochDate`, `addDateTime`. usw. **Example** ``` addWorkDays(epochDate(1659484800), numWorkDays) ``` + **Berechnete Felder** — Jedes schnell berechnete Feld, das einen `date` Wert zurückgibt. **Example** ``` calcFieldStartDate = addDateTime(10, “DD”, startDate) addWorkDays(calcFieldStartDate, numWorkDays) ``` + **Parameter** — Beliebiger `datetime` Quick-Parameter. **Example** ``` addWorkDays($paramStartDate, numWorkDays) ``` + Beliebige Kombination der oben angegebenen Argumentwerte. *numWorkDays* Eine Ganzzahl ungleich Null, die als Enddatum für die Berechnung dient. + **Literal** - Ein Integer-Literal, das direkt in den Ausdruckseditor eingegeben wurde. **Example** ``` ``` + **Datensatzfeld** - Ein beliebiges Datumsfeld aus dem Datensatz **Example** ``` ``` + **Skalarfunktion oder Berechnung** — Jede skalare Schnellfunktion, die beispielsweise eine Ganzzahlausgabe von einer anderen Funktion zurückgibt `decimalToInt``abs`, usw. **Example** ``` addWorkDays(initDate, decimalToInt(sqrt (abs(numWorkDays)) ) ) ``` + **Berechnetes Feld** — Jedes schnell berechnete Feld, das einen `date` Wert zurückgibt. **Example** ``` someOtherIntegerCalcField = (num_days * 2) + 12 addWorkDays(initDate, someOtherIntegerCalcField) ``` + **Parameter** — Beliebiger `datetime` Quick-Parameter. **Example** ``` addWorkDays(initDate, $param_numWorkDays) ``` + Beliebige Kombination der oben angegebenen Argumentwerte. ## Rückgabetyp Ganzzahl ## Ausgabewerte Zu den erwarteten Ausgabewerten gehören: + Positive Ganzzahl (wenn start\$1date < end\$1date) + Positive Ganzzahl (wenn start\$1date > end\$1date) + NULL, wenn eines oder beide Argumente einen Nullwert von `dataset field` erhalten. ## Eingabefehler Unzulässige Argumentwerte führen zu Fehlern, wie in den folgenden Beispielen dargelegt. + Die Verwendung eines literalen NULL-Werts als Argument im Ausdruck ist nicht zulässig. **Example** ``` addWorkDays(NULL, numWorkDays) ``` **Example** ``` Error At least one of the arguments in this function does not have correct type. Correct the expression and choose Create again. ``` + Die Verwendung eines Zeichenfolgenliterals als Argument oder eines anderen Datentyps als Datum im Ausdruck ist nicht zulässig. Im folgenden Beispiel sieht die Zeichenfolge **"2022-08-10"** wie ein Datum aus, ist aber tatsächlich eine Zeichenfolge. Um sie zu verwenden, müssten Sie eine Funktion verwenden, die in einen Datentyp vom Datentyp Datum konvertiert. **Example** ``` addWorkDays("2022-08-10", 10) ``` **Example** ``` Error Expression addWorkDays("2022-08-10", numWorkDays) for function addWorkDays has incorrect argument type addWorkDays(String, Number). Function syntax expects Date, Integer. ``` ## Beispiel Eine positive Ganzzahl als `numWorkDays`-Argument ergibt ein Datum vor dem Eingabedatum. Eine negative Ganzzahl als `numWorkDays`-Argument ergibt ein resultierendes Datum, das in der Vergangenheit des Eingabedatums liegt. Ein Nullwert für das `numWorkDays`-Argument ergibt denselben Wert wie das Eingabedatum, unabhängig davon, ob es auf einen Arbeitstag oder ein Wochenende fällt oder nicht. Die `addWorkDays`-Funktion arbeitet mit der Granularität: `DAY`. Die Genauigkeit kann bei keiner Granularität beibehalten werden, die niedriger oder höher als die Stufe `DAY` ist. ``` addWorkDays(startDate, endDate) ``` Nehmen wir an, es gibt ein Feld `employmentStartDate` mit den folgenden Werten: ``` 2022-08-10 2022-08-06 2022-08-07 ``` Unter Verwendung des obigen Felds und der folgenden Berechnungen wird `addWorkDays` die geänderten Werte wie unten dargestellt zurückgegeben: ``` addWorkDays(employmentStartDate, 7) 2022-08-19 2022-08-16 2022-08-16 addWorkDays(employmentStartDate, -5) 2022-08-02 2022-08-01 2022-08-03 addWorkDays(employmentStartDate, 0) 2022-08-10 2022-08-06 2022-08-07 ``` Im folgenden Beispiel wird der anteilige Gesamtbonus, der jedem Mitarbeiter zwei Jahre lang gezahlt wird, auf der Grundlage der Anzahl der Tage berechnet, die jeder Mitarbeiter tatsächlich gearbeitet hat. ``` last_day_of_work = addWorkDays(employment_start_date, 730) total_days_worked = netWorkDays(employment_start_date, last_day_of_work) total_bonus = total_days_worked * bonus_per_day ``` ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/addWorkDays-function-example.png) # Abs `abs` gibt den absoluten Wert eines bestimmten Ausdrucks zurück. ## Syntax ``` abs(expression) ``` ## Argumente *expression* Der Ausdruck muss numerisch sein. Es kann sich um einen Feldnamen, einen literalen Wert oder eine andere Funktion handeln. # Ceil `ceil` rundet einen Dezimalwert auf die nächst höhere Ganzzahl auf. Beispielsweise gibt `ceil(29.02)` `30` zurück. ## Syntax ``` ceil(decimal) ``` ## Argumente *Dezimalwert* Ein Feld, das den Datentyp "decimal", einen literalen Wert wie **17.62** oder den Aufruf einer anderen Funktion verwendet, die einen Dezimalwert ausgibt. ## Rückgabetyp Ganzzahl ## Beispiel Im folgenden Beispiel wird der Wert eines Dezimalfelds auf die nächst höhere Ganzzahl gerundet. ``` ceil(salesAmount) ``` Das Feld enthält folgende Werte. ``` 20.13 892.03 57.54 ``` Für diese Feldwerte werden die folgenden Ergebniswerte zurückgegeben. ``` 21 893 58 ``` # Coalesce `coalesce` gibt den Wert des ersten Arguments zurück, das nicht null ist. Wird ein Wert gefunden, der nicht null ist, werden die übrigen Argumente in der Liste nicht ausgewertet. Wenn alle Argumente null sind, ist das Ergebnis null. Zeichenfolgen mit einer Länge von null sind gültige Werte und gelten nicht als Werte, die null entsprechen. ## Syntax ``` coalesce(expression1, expression2 [, expression3, ...]) ``` ## Argumente `coalesce` nutzt zwei oder mehr Ausdrücke als Argumente. Alle Ausdrücke müssen vom selben Datentyp sein oder implizit in denselben Datentyp umgewandelt werden können. *Ausdruck* Der Ausdruck kann ein numerisch, vom Typ Datetime oder eine Zeichenfolge sein. Es kann sich um einen Feldnamen, einen literalen Wert oder eine andere Funktion handeln. ## Rückgabetyp `coalesce` gibt einen Wert desselben Datentyps als Eingabeargumente zurück. ## Beispiel Im folgenden Beispiel wird die Rechnungsadresse eines Kunden abgerufen (sofern vorhanden). Ist keine Rechnungsadresse vorhanden, wir die Postanschrift abgerufen. Ist auch diese nicht vorhanden, wird dem Benutzer mitgeteilt, dass keine Adresse verfügbar ist ("No address listed" (Keine Adresse angeführt)). ``` coalesce(billingAddress, streetAddress, 'No address listed') ``` # Concat `concat` verkettet zwei oder mehr Zeichenfolgen. ## Syntax ``` concat(expression1, expression2 [, expression3 ...]) ``` ## Argumente `concat` nutzt zwei oder mehr Zeichenfolgenausdrücke als Argumente. *Ausdruck* Der Ausdruck muss eine Zeichenfolge sein. Es kann der Name eines Felds sein, das den Datentyp "string" verwendet, ein literaler Wert wie **'12 Main Street'** oder der Aufruf einer Funktion, die eine Zeichenfolge ausgibt. ## Rückgabetyp Zeichenfolge ## Beispiele Im folgenden Beispiel werden drei Zeichenfolgenfelder verkettet und entsprechende Leerzeichen hinzugefügt. ``` concat(salutation, ' ', firstName, ' ', lastName) ``` Das Feld enthält folgende Werte. ``` salutation firstName lastName ------------------------------------------------------- Ms. Li Juan Dr. Ana Carolina Silva Mr. Nikhil Jayashankar ``` Für diese Feldwerte werden die folgenden Ergebniswerte zurückgegeben. ``` Ms. Li Juan Dr. Ana Carolina Silva Mr. Nikhil Jayashankar ``` Im folgenden Beispiel werden zwei Zeichenfolgenliterale verkettet. ``` concat('Hello', 'world') ``` Der folgende Wert wird zurückgegeben. ``` Helloworld ``` # contains `contains` bewertet, ob die von Ihnen angegebene Teilzeichenfolge in einem Ausdruck existiert. Wenn der Ausdruck die Teilzeichenfolge enthält, gibt contains true zurück, andernfalls wird false zurückgegeben. ## Syntax ``` contains(expression, substring, string-comparison-mode) ``` ## Argumente *expression* Der Ausdruck muss eine Zeichenfolge sein. Es kann der Name eines Felds sein, das den Datentyp "string" verwendet, ein literaler Wert wie **'12 Main Street'** oder der Aufruf einer Funktion, die eine Zeichenfolge ausgibt. *substring* Der Zeichensatz, der mit dem *Ausdruck* verglichen werden soll. Die Teilzeichenfolge kann sowohl einmal als auch mehrmals im *Ausdruck* enthalten sein. *string-comparison-mode* (Optional) Gibt den zu verwendenden Zeichenfolgenvergleichsmodus an: + `CASE_SENSITIVE` - Bei Zeichenfolgenvergleichen wird zwischen Groß- und Kleinschreibung unterschieden. + `CASE_INSENSITIVE` - Bei Zeichenfolgenvergleichen wird nicht zwischen Groß- und Kleinschreibung unterschieden. Dieser Wert wird standardmäßig auf `CASE_SENSITIVE` eingestellt, wenn er leer ist. ## Rückgabetyp Boolesch ## Beispiele ### Standardbeispiel für Groß- und Kleinschreibung Das folgende Beispiel, bei dem Groß- und Kleinschreibung beachtet wird, bewertet, ob `state_nm` **New** enthält. ``` contains(state_nm, "New") ``` Das Feld enthält folgende Werte. ``` New York new york ``` Für diese Feldwerte werden die folgenden Ergebniswerte zurückgegeben. ``` true false ``` ### Beispiel ohne Unterscheidung von Groß- und Kleinschreibung Das folgende Beispiel ohne Berücksichtigung der Groß- und Kleinschreibung bewertet, ob `state_nm` **new** enthält. ``` contains(state_nm, "new", CASE_INSENSITIVE) ``` Das Feld enthält folgende Werte. ``` New York new york ``` Für diese Feldwerte werden die folgenden Ergebniswerte zurückgegeben. ``` true true ``` ### Beispiel mit bedingten Anweisungen Die Funktion contains kann als bedingte Anweisung in den folgenden If-Funktionen verwendet werden: [AvGif](https://docs.aws.amazon.com/quicksight/latest/user/avgIf-function.html), [MiniF](https://docs.aws.amazon.com/quicksight/latest/user/minIf-function.html), [distinct\$1countIf](https://docs.aws.amazon.com/quicksight/latest/user/distinct_countIf-function.html), [countIf](https://docs.aws.amazon.com/quicksight/latest/user/countIf-function.html), [maxIf](https://docs.aws.amazon.com/quicksight/latest/user/maxIf-function.html), [medianIf](https://docs.aws.amazon.com/quicksight/latest/user/medianIf-function.html), [stdevIf](https://docs.aws.amazon.com/quicksight/latest/user/stdevIf-function.html), [stdevpIf](https://docs.aws.amazon.com/quicksight/latest/user/stdevpIf-function.html), [sumIf](https://docs.aws.amazon.com/quicksight/latest/user/sumIf-function.html), [varIf](https://docs.aws.amazon.com/quicksight/latest/user/varIf-function.html) und [varpIf](https://docs.aws.amazon.com/quicksight/latest/user/varpIf-function.html). Das folgende Beispiel summiert `Sales` nur, wenn `state_nm` **New** enthält. ``` sumIf(Sales,contains(state_nm, "New")) ``` ### Enthält KEIN Beispiel Der konditionale `NOT`-Operator kann verwendet werden, um auszuwerten, ob der Ausdruck die angegebene Teilzeichenfolge nicht enthält. ``` NOT(contains(state_nm, "New")) ``` ### Beispiel mit numerischen Werten Numerische Werte können in den Ausdrucks- oder Teilzeichenfolgenargumenten durch Anwendung der `toString`-Funktion verwendet werden. ``` contains(state_nm, toString(5) ) ``` # decimalToInt `decimalToInt` konvertiert einen Dezimalwert in den Datentyp "integer", indem das Dezimaltrennzeichen sowie alle Ziffern dahinter entfernt werden. `decimalToInt` führt keine Rundung durch. Beispielsweise gibt `decimalToInt(29.99)` `29` zurück. ## Syntax ``` decimalToInt(decimal) ``` ## Argumente *Dezimalwert* Ein Feld, das den Datentyp "decimal", einen literalen Wert wie **17.62** oder den Aufruf einer anderen Funktion verwendet, die einen Dezimalwert ausgibt. ## Rückgabetyp Ganzzahl ## Beispiel Im folgenden Beispiel wird ein Feld vom Typ "decimal" in ein Feld vom Typ "integer" konvertiert. ``` decimalToInt(salesAmount) ``` Das Feld enthält folgende Werte. ``` 20.13 892.03 57.54 ``` Für diese Feldwerte werden die folgenden Ergebniswerte zurückgegeben. ``` 20 892 57 ``` # dateDiff `dateDiff` gibt den Unterschied zwischen zwei Datumsfeldern in Tagen zurück. Wenn Sie einen Wert für den Zeitraum einschließen, gibt `dateDiff` die Differenz anstatt in Tagen im betreffenden Periodenintervall zurück. ## Syntax ``` dateDiff(date1, date2,[period]) ``` ## Argumente `dateDiff` nutzt zwei Datumsangaben als Argumente. Die Angabe eines Zeitraums ist optional. *Datum 1* Das erste Datum im Vergleich. Ein Datumsfeld oder der Aufruf einer anderen Funktion, die ein Datum ausgibt. *Datum 2* Das zweite Datum im Vergleich. Ein Datumsfeld oder der Aufruf einer anderen Funktion, die ein Datum ausgibt. *Zeitraum* Der Zeitraum, in dem die Differenz in zurückgegeben werden soll, in Anführungszeichen. Folgende Zeiträume werden unterstützt: + YYYY: Gibt den Jahresteil des Datums zurück. + Q: Gibt das Datum des ersten Tags des Quartals zurück, in das das Datum fällt. + MM: Gibt den Monatsteil des Datums zurück. + DD: Gibt den Tagesteil des Datums zurück. + WK: Gibt den Wochenteil des Datums zurück. Die Woche beginnt am Sonntag in Amazon Quick. + HH: Gibt den Stundenteil des Datums zurück. + MI: Gibt den Minutenteil des Datums zurück. + SS: Gibt den Sekundenteil des Datums zurück. + SS: Gibt den Sekundenteil des Datums zurück. ## Rückgabetyp Ganzzahl ## Beispiel Im folgenden Beispiel wird die Zeitspanne zwischen zwei Datumsangaben zurückgegeben. ``` dateDiff(orderDate, shipDate, "MM") ``` Das Feld enthält folgende Werte. ``` orderDate shipdate ============================= 01/01/18 03/05/18 09/13/17 10/20/17 ``` Für diese Feldwerte werden die folgenden Ergebniswerte zurückgegeben. ``` 2 1 ``` # endsWith `endsWith` wertet aus, ob der Ausdruck mit einer von Ihnen angegebenen Teilzeichenfolge endet. Wenn der Ausdruck mit der Teilzeichenfolge endet, gibt `endsWith` „true“ zurück, andernfalls „false“. ## Syntax ``` endsWith(expression, substring, string-comparison-mode) ``` ## Argumente *expression* Der Ausdruck muss eine Zeichenfolge sein. Es kann der Name eines Felds sein, das den Datentyp "string" verwendet, ein literaler Wert wie **'12 Main Street'** oder der Aufruf einer Funktion, die eine Zeichenfolge ausgibt. *substring* Der Zeichensatz, der mit dem *Ausdruck* verglichen werden soll. Die Teilzeichenfolge kann sowohl einmal als auch mehrmals im *Ausdruck* enthalten sein. *string-comparison-mode* (Optional) Gibt den zu verwendenden Zeichenfolgenvergleichsmodus an: + `CASE_SENSITIVE` - Bei Zeichenfolgenvergleichen wird zwischen Groß- und Kleinschreibung unterschieden. + `CASE_INSENSITIVE` - Bei Zeichenfolgenvergleichen wird nicht zwischen Groß- und Kleinschreibung unterschieden. Dieser Wert wird standardmäßig auf `CASE_SENSITIVE` eingestellt, wenn er leer ist. ## Rückgabetyp Boolesch ## Beispiele ### Standardbeispiel für Groß- und Kleinschreibung Das folgende Beispiel, bei dem Groß- und Kleinschreibung berücksichtigt wird, bewertet, ob `state_nm` mit **"York"** endet. ``` endsWith(state_nm, "York") ``` Das Feld enthält folgende Werte. ``` New York new york ``` Für diese Feldwerte werden die folgenden Ergebniswerte zurückgegeben. ``` true false ``` ### Beispiel ohne Unterscheidung von Groß- und Kleinschreibung Das folgende Beispiel ohne Berücksichtigung der Groß- und Kleinschreibung bewertet, ob `state_nm` mit **"york"** endet. ``` endsWith(state_nm, "york", CASE_INSENSITIVE) ``` Das Feld enthält folgende Werte. ``` New York new york ``` Für diese Feldwerte werden die folgenden Ergebniswerte zurückgegeben. ``` true true ``` ### Beispiel mit bedingten Anweisungen Die `endsWith`-Funktion kann als bedingte Anweisung in den folgenden If-Funktionen verwendet werden: [avgIf](https://docs.aws.amazon.com/quicksight/latest/user/avgIf-function.html), [minIf](https://docs.aws.amazon.com/quicksight/latest/user/minIf-function.html), [distinct\$1countIf](https://docs.aws.amazon.com/quicksight/latest/user/distinct_countIf-function.html), [countIf](https://docs.aws.amazon.com/quicksight/latest/user/countIf-function.html), [maxIf](https://docs.aws.amazon.com/quicksight/latest/user/maxIf-function.html), [medianIf](https://docs.aws.amazon.com/quicksight/latest/user/medianIf-function.html), [stdevIf](https://docs.aws.amazon.com/quicksight/latest/user/stdevIf-function.html), [stdevpIf](https://docs.aws.amazon.com/quicksight/latest/user/stdevpIf-function.html), [sumIf](https://docs.aws.amazon.com/quicksight/latest/user/sumIf-function.html), [varIf](https://docs.aws.amazon.com/quicksight/latest/user/varIf-function.html) und [varpIf](https://docs.aws.amazon.com/quicksight/latest/user/varpIf-function.html). Das folgende Beispiel summiert `Sales` nur, wenn `state_nm` mit **"York"** endet. ``` sumIf(Sales,endsWith(state_nm, "York")) ``` ### Enthält KEIN Beispiel Der konditionale `NOT`-Operator kann verwendet werden, um auszuwerten, ob der Ausdruck nicht mit der angegebenen Teilzeichenfolge beginnt. ``` NOT(endsWith(state_nm, "York")) ``` ### Beispiel mit numerischen Werten Numerische Werte können in den Ausdrucks- oder Teilzeichenfolgenargumenten durch Anwendung der `toString`-Funktion verwendet werden. ``` endsWith(state_nm, toString(5) ) ``` # epochDate `epochDate`[konvertiert ein Epochendatum in ein Standarddatum im Format yyyy-MM-DD **T** kk:mm:ss.sss **Z** und verwendet dabei die in Class in der Joda-Projektdokumentation angegebene Formatmustersyntax. DateTimeFormat](http://www.joda.org/joda-time/apidocs/org/joda/time/format/DateTimeFormat.html) Ein Beispiel ist `2015-10-15T19:11:51.003Z`. `epochDate`wird für Analysen unterstützt, die auf in Quick () gespeicherten Datensätzen basieren. SPICE ## Syntax ``` epochDate(epochdate) ``` ## Argumente *epochdate* Ein Epoche-Datum als ganzzahlige Darstellung eines Datums, bei der die Anzahl der Sekunden angegeben wird, die seit dem 1. Januar 1970 00:00:00 UTC verstrichen sind. *epochdate* muss eine Ganzzahl sein. Es kann der Name eines Felds sein, das den Datentyp "integer" verwendet, ein literaler Wert oder der Aufruf einer Funktion, die eine Ganzzahl ausgibt. Besteht der Ganzzahlwert aus mehr als 10 Ziffern, werden alle Ziffern nach der 10. Stelle verworfen. ## Rückgabetyp Date ## Beispiel Im folgenden Beispiel wird ein Epoche-Datum in ein Standarddatum konvertiert. ``` epochDate(3100768000) ``` Der folgende Wert wird zurückgegeben. ``` 2068-04-04T12:26:40.000Z ``` # Exp `exp` gibt die Basis des natürlichen Logarithmus von e zurück, die auf die Potenz eines bestimmten Ausdrucks erhöht wird. ## Syntax ``` exp(expression) ``` ## Argumente *expression* Der Ausdruck muss numerisch sein. Es kann sich um einen Feldnamen, einen literalen Wert oder eine andere Funktion handeln. # Extract `extract` gibt einen bestimmten Teil eines Datumwerts zurück. Wird ein zeitbezogener Teil eines Datums angefordert, das keine zeitbezogenen Informationen enthält, wird null zurückgegeben. ## Syntax ``` extract(period, date) ``` ## Argumente *Zeitraum* Der Zeitraum, den Sie aus dem Datumswert extrahieren möchten. Folgende Zeiträume werden unterstützt: + YYYY: Gibt den Jahresteil des Datums zurück. + Q: Gibt das Quartal zurück, in das das Datum fällt (1-4). + MM: Gibt den Monatsteil des Datums zurück. + DD: Gibt den Tagesteil des Datums zurück. + WD: Gibt den Wochentag als Ganzzahl zurück. Dabei erhält der Sonntag den Wert 1. + HH: Gibt den Stundenteil des Datums zurück. + MI: Gibt den Minutenteil des Datums zurück. + SS: Gibt den Sekundenteil des Datums zurück. + SS: Gibt den Sekundenteil des Datums zurück. **Anmerkung** Das Extrahieren von Millisekunden wird in Presto-Datenbanken unter Version 0.216 nicht unterstützt. *date* Ein Datumsfeld oder der Aufruf einer anderen Funktion, die ein Datum ausgibt. ## Rückgabetyp Ganzzahl ## Beispiel Im folgenden Beispiel wird der Tag aus einem Datumswert extrahiert. ``` extract('DD', orderDate) ``` Das Feld enthält folgende Werte. ``` orderDate ========= 01/01/14 09/13/16 ``` Für diese Feldwerte werden die folgenden Ergebniswerte zurückgegeben. ``` 01 13 ``` # Floor `floor` rundet einen Dezimalwert auf die nächst niedrigere Ganzzahl ab. Beispielsweise gibt `floor(29.08)` `29` zurück. ## Syntax ``` floor(decimal) ``` ## Argumente *Dezimalwert* Ein Feld, das den Datentyp "decimal", einen literalen Wert wie **17.62** oder den Aufruf einer anderen Funktion verwendet, die einen Dezimalwert ausgibt. ## Rückgabetyp Ganzzahl ## Beispiel Im folgenden Beispiel wird der Wert eines Dezimalfelds auf die nächst niedrigere Ganzzahl abgerundet. ``` floor(salesAmount) ``` Das Feld enthält folgende Werte. ``` 20.13 892.03 57.54 ``` Für diese Feldwerte werden die folgenden Ergebniswerte zurückgegeben. ``` 20 892 57 ``` # formatDate `formatDate` formatiert ein Datum in dem von Ihnen angegebenem Muster. Wenn Sie Daten vorbereiten, können Sie mit `formatDate` das Datum neu formatieren. Um ein Datum in einer Analyse neu zu formatieren, wählen Sie die Formatoption im Kontextmenü des Datumsfelds aus. ## Syntax ``` formatDate(date, ['format']) ``` ## Argumente *date* Ein Datumsfeld oder der Aufruf einer anderen Funktion, die ein Datum ausgibt. *format* (Optional) Eine Zeichenfolge, die das anzuwendende Muster enthält. Dieses Argument akzeptiert die [unter Unterstützte Datumsformate](https://docs.aws.amazon.com/quicksight/latest/user/supported-date-formats.html) angegebenen Formatmuster. Wenn Sie kein Format angeben, ist diese Zeichenfolge standardmäßig yyyy-MM-dd**T**kk: mm: ss: SSS. ## Rückgabetyp Zeichenfolge ## Beispiel Im folgenden Beispiel wird ein UTC-Datum formatiert. ``` formatDate(orderDate, 'dd-MMM-yyyy') ``` Das Feld enthält folgende Werte. ``` order date ========= 2012-12-14T00:00:00.000Z 2013-12-29T00:00:00.000Z 2012-11-15T00:00:00.000Z ``` Für diese Feldwerte werden die folgenden Ergebniswerte zurückgegeben. ``` 13 Dec 2012 28 Dec 2013 14 Nov 2012 ``` ## Beispiel Wenn das Datum beispielsweise einfache Anführungszeichen oder Apostrophe wie z. B. `yyyyMMdd'T'HHmmss` enthält, können Sie dieses Datumsformat mit einer der folgenden Methoden verarbeiten. + Schließen Sie das gesamte Datum in doppelte Anführungszeichen ein, wie im folgenden Beispiel gezeigt: ``` formatDate({myDateField}, "yyyyMMdd'T'HHmmss") ``` + Vermeiden Sie einfache Anführungszeichen oder Apostrophe, indem Sie, wie im folgenden Beispiel dargelegt, links neben ihnen einen umgekehrten Schrägstrich (`\`) hinzufügen: ``` formatDate({myDateField}, 'yyyyMMdd\'T\'HHmmss') ``` # Ifelse `ifelse` wertet einen Satz von *if*-*then*-Ausdruckspaaren aus und gibt den Wert des *then*-Arguments für das erste *if*-Argument zurück, das als "true" ausgewertet wird. Wenn keines der *if*-Argumente "true" ergibt, wird der Wert des *else*-Arguments zurückgegeben. ## Syntax ``` ifelse(if-expression-1, then-expression-1 [, if-expression-n, then-expression-n ...], else-expression) ``` ## Argumente `ifelse` erfordert mindestens ein oder mehrere *if*,*then*-Ausdruckspaar/e sowie genau einen Ausdruck für das *else*-Argument. *if-expression* Der als "true" oder "false" auszuwertende Ausdruck. Es kann sich dabei um einen Feldnamen wie **address1**, einen literalen Wert wie **'Unknown'** oder um eine Funktion wie `toString(salesAmount)` handeln. Ein Beispiel ist `isNotNull(FieldName)`. Wenn Sie mehrere AND- und OR-Operatoren im `if`-Argument verwenden, schließen Sie die Anweisungen in Klammern ein, um die Verarbeitungsreihenfolge zu bestimmen. Die folgende `if`-Argument gibt beispielsweise Datensätze mit den Monaten 1, 2 oder 5 und das Jahr 2000 zurück. ``` ifelse((month = 5 OR month < 3) AND year = 2000, 'yes', 'no') ``` Das nächste `if`-Argument verwendet dieselben Operatoren, gibt aber Datensätze mit dem Monat 5 und einem beliebigem Jahr oder den Monaten 1 oder 2 und dem Jahr 2000 zurück. ``` ifelse(month = 5 OR (month < 3 AND year = 2000), 'yes', 'no') ``` *then-expression* Der Ausdruck, der zurückgegeben werden soll, wenn dessen *if*-Argument als "true" ausgewertet wird. Es kann sich dabei um einen Feldnamen wie **address1**, einen literalen Wert wie **'Unknown'** oder um den Aufruf einer anderen Funktion handeln. Der Ausdruck muss vom gleichen Datentyp wie die anderen `then`-Argumente und das Argument `else` sein. *else-expression* Der Ausdruck, der zurückgegeben werden soll, wenn keines der *if*-Argument als "true" ausgewertet wird. Es kann sich dabei um einen Feldnamen wie **address1**, einen literalen Wert wie **'Unknown'** oder um eine Funktion wie `toString(salesAmount)` handeln. Der Ausdruck muss vom gleichen Datentyp wie alle `then`-Argumente sein. ## Rückgabetyp `ifelse` gibt einen Wert desselben Datentyps wie die Werte in *then-expression* zurück. Alle Ausdrücke, die *then* und *else* zurückgegeben haben, müssen denselben Datentyp haben oder in denselben Datentyp konvertiert werden. ## Beispiele Im folgenden Beispiel wird eine Spalte mit Aliasnamen für das Feld `country` generiert. ``` ifelse(country = "United States", "US", country = "China", "CN", country = "India", "IN", "Others") ``` In solchen Anwendungsfällen wird jeder Wert in einem Feld anhand einer Liste von Literalen ausgewertet und das Ergebnis zurückgegeben, das dem ersten übereinstimmenden Wert entspricht. Um Ihre Arbeit zu vereinfachen, wird ein Funktionswechsel empfohlen. Das vorherige Beispiel kann als folgende Anweisung mit [https://docs.aws.amazon.com/quicksight/latest/user/switch-function.html](https://docs.aws.amazon.com/quicksight/latest/user/switch-function.html) umgeschrieben werden: ``` switch(country,"United States","US","China","CN","India","IN","Others") ``` Im folgenden Beispiel wird der Umsatz pro Kunde in für Menschen lesbare Stufen unterteilt. ``` ifelse(salesPerCustomer < 1000, “VERY_LOW”, salesPerCustomer < 10000, “LOW”, salesPerCustomer < 100000, “MEDIUM”, “HIGH”) ``` Das folgende Beispiel verwendet AND, OR und NOT, um mehrere Ausdrücke mit konditionalen Operatoren zu vergleichen und Top-Kunden, die mehr als 10 Bestellungen getätigt haben und NICHT in Washington oder Oregon angesiedelt sind, eine bestimmte Werbung zukommen zu lassen. Wenn keine Werte zurückgegeben werden, wird der Wert `'n/a'` verwendet. ``` ifelse(( (NOT (State = 'WA' OR State = 'OR')) AND Orders > 10), 'Special Promotion XYZ', 'n/a') ``` In den folgenden Beispielen wird nur ODER verwendet, um eine neue Spalte zu generieren, die den Namen des jeweiligen Kontinents enthält, der `country` entspricht. ``` ifelse(country = "United States" OR country = "Canada", "North America", country = "China" OR country = "India" OR country = "Japan", "Asia", "Others") ``` Das vorherige Beispiel kann vereinfacht werden, wie im nächsten Beispiel gezeigt. Im folgenden Beispiel wird `ifelse` und[https://docs.aws.amazon.com/quicksight/latest/user/in-function.html](https://docs.aws.amazon.com/quicksight/latest/user/in-function.html) verwendet, um einen Wert in einer neuen Spalte für jede Zeile zu erstellen, in der sich der getestete Wert in einer literalen Liste befindet. Sie könnten auch `ifelse` mit [https://docs.aws.amazon.com/quicksight/latest/user/notIn-function.html](https://docs.aws.amazon.com/quicksight/latest/user/notIn-function.html) verwenden. ``` ifelse(in(country,["United States", "Canada"]), "North America", in(country,["China","Japan","India"]),"Asia","Others") ``` Autoren können eine literale Liste in einem mehrwertigen Parameter speichern und sie in den [https://docs.aws.amazon.com/quicksight/latest/user/in-function.html](https://docs.aws.amazon.com/quicksight/latest/user/in-function.html)- oder [https://docs.aws.amazon.com/quicksight/latest/user/notIn-function.html](https://docs.aws.amazon.com/quicksight/latest/user/notIn-function.html)-Funktionen verwenden. Das folgende Beispiel entspricht dem vorherigen Beispiel, mit der Ausnahme, dass die literalen Listen in zwei mehrwertigen Parametern gespeichert werden. ``` ifelse(in(country,${NorthAmericaCountryParam}), "North America", in(country,${AsiaCountryParam}),"Asia", "Others") ``` Im folgenden Beispiel wird eine Gruppe basierend auf dem Gesamtumsatz zu einem Verkaufsdatensatz zugewiesen. Die Struktur der einzelnen `if-then`-Phrasen ahmt das Verhalten von *between* nach, einem Schlüsselwort, das derzeit in berechneten Feldausdrücken nicht funktioniert. Das Ergebnis des Vergleichs `salesTotal >= 0 AND salesTotal < 500` gibt beispielsweise dieselben Werte zurück wie der SQL-Vergleich `salesTotal between 0 and 499`. ``` ifelse(salesTotal >= 0 AND salesTotal < 500, 'Group 1', salesTotal >= 500 AND salesTotal < 1000, 'Group 2', 'Group 3') ``` Im folgenden Beispiel wird geprüft, ob ein NULL-Wert vorliegt, wobei `coalesce` verwendet wird, um den ersten Wert zurückzugeben, der nicht NULL ist. Anstatt sich die Bedeutung einer NULL in einem Datumsfeld merken zu müssen, können Sie stattdessen eine lesbare Beschreibung verwenden. Wenn das Verbindungsdatum NULL ist, gibt das Beispiel das Sperrdatum zurück, es sei denn, beide Werte sind NULL. Dann gibt `coalesce(DiscoDate, SuspendDate, '12/31/2491')` `'12/31/2491'` zurück. Der Rückgabewert muss mit den anderen Datentypen übereinstimmen. Dieses Datum mag wie ein ungewöhnlicher Wert erscheinen, aber ein Datum im 25. Jahrhundert simuliert vernünftigerweise das „Ende der Zeit“, definiert als das höchste Datum in einem Data Mart. ``` ifelse ( (coalesce(DiscoDate, SuspendDate, '12/31/2491') = '12/31/2491'), 'Active subscriber', 'Inactive subscriber') ``` Das Folgende zeigt ein komplexeres Beispiel in einem besser lesbaren Format, nur um zu zeigen, dass Sie Ihren gesamten Code nicht in eine lange Zeile komprimieren müssen. Dieses Beispiel ermöglicht mehrere Vergleiche des Werts eines Umfrageergebnisses. Es verarbeitet potenzielle NULL-Werte für dieses Feld und kategorisiert zwei zulässige Bereiche. Es kennzeichnet auch einen Bereich, der mehr Tests erfordert, und einen anderen, der ungültig ist (außerhalb des zulässigen Bereichs). Für alle verbleibenden Werte wird die `else`-Bedingung angewendet, und die Zeile wird so gekennzeichnet, dass drei Jahre nach dem Datum in dieser Zeile ein erneuter Test erforderlich ist. ``` ifelse ( isNull({SurveyResult}), 'Untested', {SurveyResult}=1, 'Range 1', {SurveyResult}=2, 'Range 2', {SurveyResult}=3, 'Need more testing', {SurveyResult}=99, 'Out of Range', concat ( 'Retest by ', toString ( addDateTime(3, "YYYY", {Date}) ) ) ) ``` Im folgenden Beispiel wird einer Gruppe von Bundesstaaten ein „manuell“ erstellter Regionsname zugewiesen. Außerdem werden Leerzeichen und Kommentare in `/* */` gepackt verwendet, um die Verwaltung des Codes zu vereinfachen. ``` ifelse ( /* NE REGION*/ locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0, 'Northeast', /* SE REGION*/ locate('Georgia, Alabama, South Carolina, Louisiana',{State}) > 0, 'Southeast', 'Other Region' ) ``` Die Logik für die Kennzeichnung von Regionen gliedert sich wie folgt: 1. Wir listen die Staaten auf, die wir für jede Region benötigen, und setzen jede Liste in Anführungszeichen, sodass jede Liste zu einer Zeichenfolge wie der Folgenden wird: + `'New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire'` + `'Georgia, Alabama, South Carolina, Louisiana'` + Sie können weitere Sets hinzufügen oder Länder, Städte, Provinzen oder What3Words verwenden, wenn Sie möchten. 1. Wir fragen, ob der Wert für `State` (für jede Zeile) in der Liste gefunden wurde, indem wir die `locate`-Funktion verwenden, um einen Wert ungleich Null zurückzugeben, wenn das Bundesland in der Liste wie im Folgenden gefunden wird. ``` locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) and locate('Georgia, Alabama, South Carolina, Louisiana',{State}) ``` 1. Die `locate`-Funktion gibt eine Zahl statt eines `TRUE` oder `FALSE` zurück, aber `ifelse` benötigt aber den booleschen Wert `TRUE`/`FALSE`. Um dies zu umgehen, können wir das Ergebnis von `locate` mit einer Zahl vergleichen. Wenn der Status in der Liste enthalten ist, ist der Rückgabewert größer als Null. 1. Fragen Sie, ob der Staat vorhanden ist. ``` locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0 ``` 1. Wenn es die Region gibt, kennzeichnen Sie sie als die spezifische Region, in diesem Fall als Nordostregion. ``` /*The if expression:*/ locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0, /*The then expression:*/ 'Northeast', ``` 1. Da wir Bundesstaaten haben, die nicht in einer Liste enthalten sind, und weil `ifelse` einen einzigen `else`-Ausdruck erfordert, stellen wir `'Other Region'` als Bezeichnung für die übrigen Bundesstaaten zur Verfügung. ``` /*The if expression:*/ locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0, /*The then expression:*/ 'Northeast', /*The else expression:*/ 'Other Region' ``` 1. Wir packen das alles in die `ifelse( )`-Funktion, um die endgültige Version zu erhalten. Im folgenden Beispiel werden die Bundesstaaten der Region Südosten, die im Original enthalten waren, weggelassen. Sie können sie anstelle des *``*-Tags wieder hinzufügen. Wenn Sie weitere Regionen hinzufügen möchten, können Sie weitere Kopien dieser beiden Zeilen erstellen und die Liste der Bundesstaaten an Ihren Zweck anpassen. Sie können den Namen der Region so ändern, dass er zu Ihnen passt, und den Feldnamen von `State` beliebig nach Bedarf ändern. ``` ifelse ( /*The if expression:*/ locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0, /*The then expression:*/ 'Northeast', /**/ /*The else expression:*/ 'Other Region' ) ``` **Anmerkung** Es gibt andere Möglichkeiten, den ersten Vergleich für den if-Ausdruck durchzuführen. Nehmen wir zum Beispiel an, Sie stellen die Frage „Welche Staaten fehlen in dieser Liste nicht?“ statt „Welche Staaten stehen auf der Liste?“ Wenn Sie dies tun, könnten Sie es anders formulieren. Sie könnten die Locate-Anweisung mit Null vergleichen, um Werte zu finden, die in der Liste fehlen, und sie dann mit dem NOT-Operator folgendermaßen als „nicht fehlend“ klassifizieren. ``` /*The if expression:*/ NOT (locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) = 0), ``` Beide Versionen sind korrekt. Die Version, die Sie wählen, sollte für Sie und Ihr Team am sinnvollsten sein, sodass Sie sie problemlos verwalten können. Wenn alle Optionen gleich erscheinen, wählen Sie die einfachste. # in `in` bewertet, ob ein Ausdruck in einer literalen Liste existiert. Wenn die Liste den Ausdruck enthält, wird wahr zurückgegeben, andernfalls falsch. `in` unterscheidet bei Eingaben vom Typ Zeichenfolge zwischen Groß- und Kleinschreibung. `in` akzeptiert zwei Arten von literalen Listen: eine ist eine manuell eingegebene Liste und die andere ist ein [mehrwertiger Parameter.](https://docs.aws.amazon.com/quicksight/latest/user/parameters-in-quicksight.html) ## Syntax Verwenden einer manuell eingegebenen Liste: ``` in(expression, [literal-1, ...]) ``` Verwendung eines mehrwertigen Parameters: ``` in(expression, $multivalue_parameter) ``` ## Argumente *expression* Der Ausdruck, der mit den Elementen in der literalen Liste verglichen werden soll. Dabei kann es sich um einen Feldnamen wie `address`, einen literalen Wert wie „**Unknown**„, einen Einzelwertparameter oder einen Aufruf einer anderen Skalarfunktion handeln — vorausgesetzt, es handelt sich bei dieser Funktion nicht um eine Aggregatfunktion oder eine Tabellenberechnung. *Literale Liste* (erforderlich) Dies kann eine manuell eingegebene Liste oder ein mehrwertiger Parameter sein. Dieses Argument akzeptiert bis zu 5.000 Elemente. Bei einer direkten Abfrage an eine Datenquelle eines Drittanbieters, beispielsweise Oracle oder Teradata, kann die Einschränkung jedoch geringer sein. + ***manuell eingegebene Liste*** — Ein oder mehrere literale Werte in einer Liste, die mit dem Ausdruck verglichen werden sollen. Die Liste sollte in eckige Klammern gesetzt werden. Alle zu vergleichenden Literale müssen denselben Datentyp wie der Ausdruck haben. + ***Mehrwertiger Parameter*** — Ein vordefinierter mehrwertiger Parameter, der als literale Liste übergeben wird. Der mehrwertige Parameter muss denselben Datentyp wie der Ausdruck haben. ## Rückgabetyp Boolesch „TRUE“/„FALSE“ ## Beispiel mit einer statischen Liste Im folgenden Beispiel wird das Feld `origin_state_name` nach Werten in einer Zeichenfolgenliste ausgewertet. Beim Vergleich von Zeichenfolgeneingaben unterstützt `in` nur den Vergleich zwischen Groß- und Kleinschreibung. ``` in(origin_state_name,["Georgia", "Ohio", "Texas"]) ``` Das Feld enthält folgende Werte. ``` "Washington" "ohio" "Texas" ``` Für diese Feldwerte werden die folgenden Ergebniswerte zurückgegeben. ``` false false true ``` Der dritte Rückgabewert ist true, da nur „Texas“ einer der eingeschlossenen Werte ist. Im folgenden Beispiel wird das Feld `fl_date` nach Werten in einer Zeichenfolgenliste ausgewertet. Um dem Typ zu entsprechen, wird `toString` verwendet, um den Datumstyp in den Zeichenfolgentyp umzuwandeln. ``` in(toString(fl_date),["2015-05-14","2015-05-15","2015-05-16"]) ``` ![\[Ein Image der Ergebnisse des Funktionsbeispiels in Tabellenform.\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/in-function-example-manual-list.png) Literale und NULL-Werte werden im Ausdrucksargument unterstützt, um mit den Literalen in der Liste verglichen zu werden. In den beiden folgenden Beispielen wird eine neue Spalte mit TRUE-Werten generiert. ``` in("Washington",["Washington","Ohio"]) ``` ``` in(NULL,[NULL,"Ohio"]) ``` ## Beispiel mit mehrwertigem Parameter Nehmen wir an, ein Autor erstellt einen [mehrwertigen Parameter](https://docs.aws.amazon.com/quicksight/latest/user/parameters-in-quicksight.html), der eine Liste aller Staatsnamen enthält. Dann fügt der Autor ein Steuerelement hinzu, mit dem der Leser Werte aus der Liste auswählen kann. Als Nächstes wählt der Leser drei Werte - „Georgia“, „Ohio“ und „Texas“ - aus dem Dropdownlisten-Steuerelement des Parameters aus. In diesem Fall entspricht der folgende Ausdruck dem ersten Beispiel, in dem diese drei Bundesstaatennamen als literale Liste übergeben werden, die mit dem Feld `original_state_name` verglichen werden soll. ``` in (origin_state_name, ${stateName MultivalueParameter}) ``` ## Beispiel mit `ifelse` `in` kann als boolescher Wert in andere Funktionen verschachtelt werden. Ein Beispiel ist, dass Autoren jeden Ausdruck in einer Liste auswerten und den gewünschten Wert mithilfe von `in` und `ifelse` zurückgeben können. Im folgenden Beispiel wird ausgewertet, ob sich das `dest_state_name` eines Flug in einer bestimmten Liste von US-Bundesstaaten befindet, und es werden auf der Grundlage des Vergleichs verschiedene Kategorien der Bundesstaaten zurückgegeben. ``` ifelse(in(dest_state_name,["Washington", "Oregon","California"]), "WestCoastUSState", "Other US State") ``` ![\[Ein Image der Ergebnisse des Funktionsbeispiels in Tabellenform.\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/in-function-with-ifelse.png) # intToDecimal `intToDecimal` konvertiert einen Ganzzahlwert in den Datentyp "decimal". ## Syntax ``` intToDecimal(integer) ``` ## Argumente *int* Ein Feld, das den Datentyp"integer", einen literalen Wert wie **14** oder den Aufruf einer anderen Funktion verwendet, die eine Ganzzahl ausgibt. ## Rückgabetyp Dezimalzahl (fest) in der älteren Datenaufbereitung. Dezimal (Float) in der neuen Datenaufbereitungserfahrung. ## Beispiel Im folgenden Beispiel wird ein Feld vom Typ "integer" in ein Feld vom Typ "decimal" konvertiert. ``` intToDecimal(price) ``` Das Feld enthält folgende Werte. ``` 20 892 57 ``` Für diese Feldwerte werden die folgenden Ergebniswerte zurückgegeben. ``` 20.0 892.0 58.0 ``` Sie können innerhalb einer Analyse Formatierung anwenden, um z. B. `price` als Währung zu formatieren. # isNotNull `isNotNull` wertet einen Ausdruck aus, um zu prüfen, ob dieser nicht null ist. Wenn der Ausdruck nicht null ist, gibt `isNotNull` "true" zurück, andernfalls "false". ## Syntax ``` isNotNull(expression) ``` ## Argumente *expression* Der als "null" oder "nicht null" auszuwertende Ausdruck. Es kann sich dabei um einen Feldnamen wie **address1** handeln oder um den Aufruf einer anderen Funktion, die eine Zeichenfolge ausgibt. ## Rückgabetyp Boolesch ## Beispiel Im folgenden Beispiel wird das Feld "sales\$1amount" auf Null-Werte überprüft. ``` isNotNull(salesAmount) ``` Das Feld enthält folgende Werte. ``` 20.13 (null) 57.54 ``` Für diese Feldwerte werden die folgenden Ergebniswerte zurückgegeben. ``` true false true ``` # isNull `isNull` wertet einen Ausdruck aus, um zu prüfen, ob dieser null ist. Wenn der Ausdruck null ist, gibt `isNull` "true" zurück, andernfalls "false". ## Syntax ``` isNull(expression) ``` ## Argumente *expression* Der als "null" oder "nicht null" auszuwertende Ausdruck. Es kann sich dabei um einen Feldnamen wie **address1** handeln oder um den Aufruf einer anderen Funktion, die eine Zeichenfolge ausgibt. ## Rückgabetyp Boolesch ## Beispiel Im folgenden Beispiel wird das Feld "sales\$1amount" auf Null-Werte überprüft. ``` isNull(salesAmount) ``` Das Feld enthält folgende Werte. ``` 20.13 (null) 57.54 ``` Für diese Feldwerte werden die folgenden Ergebniswerte zurückgegeben. ``` false true false ``` Das folgende Beispiel testet, ob eine `ifelse`-Anweisung einen NULL-Wert enthält, und gibt stattdessen einen menschenlesbaren Wert zurück. ``` ifelse( isNull({ActiveFlag}) , 'Inactive', 'Active') ``` # isWorkDay `isWorkDay` wertet einen bestimmten Wert für Datum und Uhrzeit aus, um festzustellen, ob es sich bei dem Wert um einen Arbeitstag handelt oder nicht. `isWorkDay` nimmt eine 5-tägige Standardarbeitswoche an, die am Montag beginnt und am Freitag endet. Es wird davon ausgegangen, dass Samstag und Sonntag Wochenenden sind. Die Funktion berechnet ihr Ergebnis immer mit der `DAY`-Granularität und schließt das angegebene Eingabedatum aus. ## Syntax ``` isWorkDay(inputDate) ``` ## Argumente *inputDate* (Eingabedatum) Der Wert für Datum und Uhrzeit, den Sie auswerten möchten. Gültige Werte sind: + Datensatzfelder: Jedes `date`-Feld aus dem Datensatz, dem Sie diese Funktion hinzufügen. + Datumsfunktionen: Jede Datumsausgabe einer anderen `date`-Funktion, zum Beispiel `parseDate`. + Berechnete Felder: Jedes schnell berechnete Feld, das einen `date` Wert zurückgibt. + Parameter: Beliebiger `DateTime` Quick-Parameter. ## Rückgabetyp Ganzzahl (`0` oder `1`) ## Beispiel Das folgende Beispiel bestimmt, ob es sich bei dem `application_date`-Feld um einen Arbeitstag handelt oder nicht. Nehmen wir an, es gibt ein Feld namens `application_date` mit den folgenden Werten: ``` 2022-08-10 2022-08-06 2022-08-07 ``` Wenn Sie diese Felder verwenden und die folgenden Berechnungen hinzufügen, gibt `isWorkDay` die folgenden Werte zurück: ``` isWorkDay({application_date}) 1 0 0 ``` Im folgenden Beispiel werden Mitarbeiter gefiltert, deren Beschäftigung an einem Werktag endet, und anhand der bedingten Formatierung bestimmt, ob ihre Beschäftigung an einem Werktag oder an einem Wochenende begonnen hat: ``` is_start_date_work_day = isWorkDay(employment_start_date) is_end_date_work_day = isWorkDay(employment_end_date) ``` ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/isWorkDay-example.png) # Left `left` gibt die linken Zeichen einer Zeichenfolge zurück, einschließlich Leerzeichen. Sie geben die Anzahl der zurückzugebenden Zeichen an. ## Syntax ``` left(expression, limit) ``` ## Argumente *expression* Der Ausdruck muss eine Zeichenfolge sein. Es kann der Name eines Felds sein, das den Datentyp "string" verwendet, ein literaler Wert wie **'12 Main Street'** oder der Aufruf einer Funktion, die eine Zeichenfolge ausgibt. *limit* Die Anzahl der Zeichen, die vom *Ausdruck* zurückgegeben werden, beginnend mit dem ersten Zeichen der Zeichenfolge. ## Rückgabetyp Zeichenfolge ## Beispiel Im folgenden Beispiel werden die ersten 3 Zeichen einer Zeichenfolge zurückgegeben. ``` left('Seattle Store #14', 3) ``` Der folgende Wert wird zurückgegeben. ``` Sea ``` # Locate `locate` sucht eine Teilzeichenfolge, die Sie innerhalb einer anderen Zeichenfolge angeben und gibt die Anzahl der Zeichen zurück, bis das erste Zeichen der Teilzeichenfolge erreicht ist. Die Funktion gibt 0 zurück, wenn die Teilzeichenfolge nicht gefunden wird. Die Funktion basiert auf 1. ## Syntax ``` locate(expression, substring, start) ``` ## Argumente *expression* Der Ausdruck muss eine Zeichenfolge sein. Es kann der Name eines Felds sein, das den Datentyp "string" verwendet, ein literaler Wert wie **'12 Main Street'** oder der Aufruf einer Funktion, die eine Zeichenfolge ausgibt. *substring* Die Zeichen im *Ausdruck*, nach denen Sie suchen möchten. Die Teilzeichenfolge kann sowohl einmal als auch mehrmals im *Ausdruck* enthalten sein. *start* (Optional) Wenn die *Teilzeichenfolge* mehrmals vorhanden ist, nutzen Sie *start*, um festzulegen, an welcher Stelle die Funktion in der Zeichenfolge mit der Suche nach der Teilzeichenfolge beginnen soll. Angenommen, Sie suchen nach dem zweiten Vorkommen der Teilzeichenfolge und gehen davon aus, dass diese in der Regel nach den ersten 10 Zeichen vorkommt. Sie geben ein *start*-Wert von 10 ein. Sie sollte bei 1 beginnen. ## Rückgabetyp Ganzzahl ## Beispiele Im folgenden Beispiel werden Informationen zum ersten Vorkommen der Teilzeichenfolge "and" in einer Zeichenfolge zurückgegeben. ``` locate('1 and 2 and 3 and 4', 'and') ``` Der folgende Wert wird zurückgegeben. ``` 3 ``` Im folgenden Beispiel werden Informationen darüber zurückgeben, wann die Teilzeichenfolge "and" das erste Mal nach dem vierten Zeichen vorkommt. ``` locate('1 and 2 and 3 and 4', 'and', 4) ``` Der folgende Wert wird zurückgegeben. ``` 9 ``` # Log `log` gibt den Logarithmus mit der Basis 10 eines bestimmten Ausdrucks zurück. ## Syntax ``` log(expression) ``` ## Argumente *expression* Der Ausdruck muss numerisch sein. Es kann sich um einen Feldnamen, einen literalen Wert oder eine andere Funktion handeln. # Ln `ln` gibt den natürlichen Logarithmus eines bestimmten Ausdrucks zurück. ## Syntax ``` ln(expression) ``` ## Argumente *expression* Der Ausdruck muss numerisch sein. Es kann sich um einen Feldnamen, einen literalen Wert oder eine andere Funktion handeln. # Ltrim `ltrim` entfernt vorangestellte Leerzeichen aus einer Zeichenfolge. ## Syntax ``` ltrim(expression) ``` ## Argumente *expression* Der Ausdruck muss eine Zeichenfolge sein. Es kann der Name eines Felds sein, das den Datentyp "string" verwendet, ein literaler Wert wie **'12 Main Street'** oder der Aufruf einer Funktion, die eine Zeichenfolge ausgibt. ## Rückgabetyp Zeichenfolge ## Beispiel Im folgenden Beispiel werden vorangestellte Leerzeichen aus einer Zeichenfolge entfernt. ``` ltrim(' Seattle Store #14') ``` Der folgende Wert wird zurückgegeben. ``` Seattle Store #14 ``` # Mod Verwenden Sie die Funktion `mod`, um den Rest zu finden, nachdem die Zahl durch den Divisor geteilt wurde. Sie können die Funktion `mod` oder den Modulo-Operator (%) synonym verwenden. ## Syntax ``` mod(number, divisor) ``` ``` number%divisor ``` ## Argumente *number (Zahl* Die Zahl ist die positive Ganzzahl, die Sie teilen und für die Sie den Rest suchen möchten. *Divisor* Der Divisor ist die positive Ganzzahl, durch die Sie dividieren. Wenn der Divisor Null ist, gibt diese Funktion einen Fehler beim Dividieren durch 0 zurück. ## Beispiel Die folgenden Beispiele geben als Modulo 17 zurück, wenn durch 6 geteilt wird. Im ersten Beispiel wird der Operator % verwendet, und im zweiten Beispiel wird die Funktion mod verwendet. ``` 17%6 ``` ``` mod( 17, 6 ) ``` Der folgende Wert wird zurückgegeben. ``` 5 ``` # netWorkDays `netWorkDays`gibt die Anzahl der Arbeitstage zwischen den beiden angegebenen Datumsfeldern oder sogar benutzerdefinierte Datumswerte zurück, die mit anderen Quick Date-Funktionen wie `parseDate` oder `epochDate` als Ganzzahl generiert wurden. `netWorkDays` nimmt eine 5-tägige Standardarbeitswoche an, die am Montag beginnt und am Freitag endet. Es wird davon ausgegangen, dass Samstag und Sonntag Wochenenden sind. Die Berechnung beinhaltet sowohl als `startDate` auch `endDate`. Die Funktion arbeitet weiter und zeigt Ergebnisse für die DAY-Granularität an. ## Syntax ``` netWorkDays(startDate, endDate) ``` ## Argumente *startDate* Ein gültiges Datum ungleich NULL, das als Startdatum für die Berechnung dient. + Datensatzfelder: Jedes `date`-Feld aus dem Datensatz, dem Sie diese Funktion hinzufügen. + Datumsfunktionen: Jede Datumsausgabe einer anderen `date`-Funktion, zum Beispiel `parseDate`. + Berechnete Felder: Jedes schnell berechnete Feld, das einen `date` Wert zurückgibt. + Parameter: Beliebiger `DateTime` Quick-Parameter. + Beliebige Kombination der oben angegebenen Argumentwerte. *endDate* Ein gültiges Datum ungleich NULL, das als Enddatum für die Berechnung dient. + Datensatzfelder: Jedes `date`-Feld aus dem Datensatz, dem Sie diese Funktion hinzufügen. + Datumsfunktionen: Jede Datumsausgabe einer anderen `date`-Funktion, zum Beispiel `parseDate`. + Berechnete Felder: Jedes schnell berechnete Feld, das einen `date` Wert zurückgibt. + Parameter: Beliebiger `DateTime` Quick-Parameter. + Beliebige Kombination der oben angegebenen Argumentwerte. ## Rückgabetyp Ganzzahl ## Ausgabewerte Zu den erwarteten Ausgabewerten gehören: + Positive Ganzzahl (wenn start\$1date < end\$1date) + Positive Ganzzahl (wenn start\$1date > end\$1date) + NULL, wenn eines oder beide Argumente einen Nullwert von `dataset field` erhalten. ## Beispiel Im folgenden Beispiel wird die Anzahl der Arbeitstage zurückgegeben, die zwischen zwei Daten liegen. Nehmen wir an, es gibt ein Feld namens `application_date` mit den folgenden Werten: ``` netWorkDays({startDate}, {endDate}) ``` Das Feld enthält folgende Werte. ``` startDate endDate netWorkDays 9/4/2022 9/11/2022 5 9/9/2022 9/2/2022 -6 9/10/2022 9/11/2022 0 9/12/2022 9/12/2022 1 ``` Im folgenden Beispiel werden die Anzahl der Arbeitstage jedes Mitarbeiters und das pro Tag für jeden Mitarbeiter ausgegebene Gehalt berechnet: ``` days_worked = netWorkDays({employment_start_date}, {employment_end_date}) salary_per_day = {salary}/{days_worked} ``` Im folgenden Beispiel werden Mitarbeiter gefiltert, deren Beschäftigung an einem Werktag endet, und anhand der bedingten Formatierung bestimmt, ob ihre Beschäftigung an einem Werktag oder an einem Wochenende begonnen hat: ``` is_start_date_work_day = netWorkDays(employment_start_date) is_end_date_work_day = netWorkDays(employment_end_date) ``` ![\[alt text not found\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/netWorkDays-function-example.png) # Now Bei Datenbank-Datasets, die direkt die Datenbank abfragen, gibt `now` das aktuelle Datum und die aktuelle Uhrzeit zurück. Dabei werden die Einstellungen und das Format verwendet, die für den Datenbankserver konfiguriert sind. Bei SPICE- und Salesforce-Datasets gibt `now` das UTC-Datum und die UTC-Zeit im Format `yyyy-MM-ddTkk:mm:ss:SSSZ` zurück (beispielsweise 2015-10-15T19:11:51:003Z). ## Syntax ``` now() ``` ## Rückgabetyp Date # notIn `notIn` bewertet, ob ein Ausdruck in einer literalen Liste existiert. Wenn die Liste den Ausdruck nicht enthält, gibt `notIn` true zurück, andernfalls false. `notIn` unterscheidet bei Eingaben vom Typ Zeichenfolge zwischen Groß- und Kleinschreibung. `notIn` akzeptiert zwei Arten von literalen Listen: eine ist eine manuell eingegebene Liste und die andere ist ein [mehrwertiger Parameter.](https://docs.aws.amazon.com/quicksight/latest/user/parameters-in-quicksight.html) ## Syntax Verwenden einer manuell eingegebenen Liste: ``` notIn(expression, [literal-1, ...]) ``` Verwendung eines mehrwertigen Parameters: ``` notIn(expression, $multivalue_parameter) ``` ## Argumente *expression* Der Ausdruck, der mit den Elementen in der literalen Liste verglichen werden soll. Dabei kann es sich um einen Feldnamen wie `address`, einen literalen Wert wie „**Unknown**„, einen Einzelwertparameter oder einen Aufruf einer anderen Skalarfunktion handeln — vorausgesetzt, es handelt sich bei dieser Funktion nicht um eine Aggregatfunktion oder eine Tabellenberechnung. *Literale Liste* (erforderlich) Dies kann eine manuell eingegebene Liste oder ein mehrwertiger Parameter sein. Dieses Argument akzeptiert bis zu 5.000 Elemente. Bei einer direkten Abfrage an eine Datenquelle eines Drittanbieters, beispielsweise Oracle oder Teradata, kann die Einschränkung jedoch geringer sein. + ***manuell eingegebene Liste*** — Ein oder mehrere literale Werte in einer Liste, die mit dem Ausdruck verglichen werden sollen. Die Liste sollte in eckige Klammern gesetzt werden. Alle zu vergleichenden Literale müssen denselben Datentyp wie der Ausdruck haben. + ***Mehrwertiger Parameter*** — Ein vordefinierter mehrwertiger Parameter, der als literale Liste übergeben wird. Der mehrwertige Parameter muss denselben Datentyp wie der Ausdruck haben. ## Rückgabetyp Boolesch „TRUE“/„FALSE“ ## Beispiel mit einer manuell eingegebenen Liste Im folgenden Beispiel wird das Feld `origin_state_name` nach Werten in einer Zeichenfolgenliste ausgewertet. Beim Vergleich von Zeichenfolgeneingaben unterstützt `notIn` nur den Vergleich zwischen Groß- und Kleinschreibung. ``` notIn(origin_state_name,["Georgia", "Ohio", "Texas"]) ``` Das Feld enthält folgende Werte. ``` "Washington" "ohio" "Texas" ``` Für diese Feldwerte werden die folgenden Ergebniswerte zurückgegeben. ``` true true false ``` Der dritte Rückgabewert ist false, weil nur „Texas“ einer der ausgeschlossenen Werte ist. Im folgenden Beispiel wird das Feld `fl_date` nach Werten in einer Zeichenfolgenliste ausgewertet. Um dem Typ zu entsprechen, wird `toString` verwendet, um den Datumstyp in den Zeichenfolgentyp umzuwandeln. ``` notIn(toString(fl_date),["2015-05-14","2015-05-15","2015-05-16"]) ``` ![\[Ein Image der Ergebnisse des Funktionsbeispiels in Tabellenform.\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/notin-function-example-manual-list.png) Literale und NULL-Werte werden im Ausdrucksargument unterstützt, um mit den Literalen in der Liste verglichen zu werden. In den beiden folgenden Beispielen wird eine neue Spalte mit FALSE-Werten generiert. ``` notIn("Washington",["Washington","Ohio"]) ``` ``` notIn(NULL,[NULL,"Ohio"]) ``` ## Beispiel mit mehrwertigem Parameter Nehmen wir an, ein Autor erstellt einen [mehrwertigen Parameter](https://docs.aws.amazon.com/quicksight/latest/user/parameters-in-quicksight.html), der eine Liste aller Staatsnamen enthält. Dann fügt der Autor ein Steuerelement hinzu, mit dem der Leser Werte aus der Liste auswählen kann. Als Nächstes wählt der Leser drei Werte - „Georgia“, „Ohio“ und „Texas“ - aus dem Dropdownlisten-Steuerelement des Parameters aus. In diesem Fall entspricht der folgende Ausdruck dem ersten Beispiel, in dem diese drei Bundesstaatennamen als literale Liste übergeben werden, die mit dem Feld `original_state_name` verglichen werden soll. ``` notIn (origin_state_name, ${stateName MultivalueParameter}) ``` ## Beispiel mit `ifelse` `notIn` kann als boolescher Wert in andere Funktionen verschachtelt werden. Ein Beispiel ist, dass Autoren jeden Ausdruck in einer Liste auswerten und den gewünschten Wert mithilfe von `notIn` und `ifelse` zurückgeben können. Im folgenden Beispiel wird ausgewertet, ob sich das `dest_state_name` eines Flug in einer bestimmten Liste von US-Bundesstaaten befindet, und es werden auf der Grundlage des Vergleichs verschiedene Kategorien der Bundesstaaten zurückgegeben. ``` ifelse(notIn(dest_state_name,["Washington", "Oregon","California"]), "notWestCoastUSState", "WestCoastUSState") ``` ![\[Ein Image der Ergebnisse des Funktionsbeispiels in Tabellenform.\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/notin-function-with-ifelse.png) # nullIf `nullIf` vergleicht zwei Ausdrücke. Sind diese gleich, gibt die Funktion null zurück. Sind sie nicht gleich, gibt die Funktion den ersten Ausdruck zurück. ## Syntax ``` nullIf(expression1, expression2) ``` ## Argumente `nullIf` nutzt zwei Ausdrücke als Argumente. *Ausdruck* Der Ausdruck kann ein numerisch, vom Typ Datetime oder eine Zeichenfolge sein. Es kann sich um einen Feldnamen, einen literalen Wert oder eine andere Funktion handeln. ## Rückgabetyp Zeichenfolge ## Beispiel Im folgenden Beispiel wird null zurückgegeben, wenn der Grund für eine Lieferverzögerung unbekannt ist (delay reason = unknown). ``` nullIf(delayReason, 'unknown') ``` Das Feld enthält folgende Werte. ``` delayReason ============ unknown back ordered weather delay ``` Für diese Feldwerte werden die folgenden Ergebniswerte zurückgegeben. ``` (null) back ordered weather delay ``` # parseDate `parseDate`analysiert eine Zeichenfolge, um festzustellen, ob sie einen Datumswert enthält, und gibt ein Standarddatum in dem Format zurück `yyyy-MM-ddTkk:mm:ss.SSSZ` (unter Verwendung der Formatmuster-Syntax, die in [Class DateTimeFormat](http://www.joda.org/joda-time/apidocs/org/joda/time/format/DateTimeFormat.html) in der Joda-Projektdokumentation angegeben ist), zum Beispiel 2015-10-15T 19:11:51.003 Z. Diese Funktion gibt alle Zeilen mit einem Datum in einem gültigen Format zurück und überspringt alle anderen Zeilen (auch Zeilen mit Nullwerten). Quick unterstützt Daten im Bereich vom 1. Januar 1900 00:00:00 UTC bis 31. Dezember 2037 23:59:59 UTC. [Weitere Informationen finden Sie unter Unterstützte Datumsformate.](https://docs.aws.amazon.com/quicksight/latest/user/supported-date-formats.html) ## Syntax ``` parseDate(expression, ['format']) ``` ## Argumente *expression* Der Ausdruck muss eine Zeichenfolge sein. Es kann der Name eines Felds sein, das den Datentyp "string" verwendet, ein literaler Wert wie **'1/1/2016'** oder der Aufruf einer Funktion, die eine Zeichenfolge ausgibt. *format* (Optional) Eine Zeichenfolge mit einem Formatmuster, das mit *date\$1string* übereinstimmen muss. Wenn Sie beispielsweise ein Feld mit Daten wie verwenden**01/03/2016**, geben Sie das Format 'MM/dd/yyyy' an. Wenn Sie kein Format angeben, wird standardmäßig `yyyy-MM-dd` verwendet. Zeilen, deren Daten nicht dem *Format* entsprechen, werden übersprungen. Basierend auf dem verwendeten Dataset-Typ werden unterschiedliche Datumsformate unterstützt. In der folgenden Tabelle finden Sie Details zu den unterstützten Datumsformaten. **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/parseDate-function.html) ## Rückgabetyp Date ## Beispiel Im folgenden Beispiel wird `prodDate` ausgewertet, um zu bestimmen, ob Datumswerte enthalten sind. ``` parseDate(prodDate, 'MM/dd/yyyy') ``` Das Feld enthält folgende Werte. ``` prodDate -------- 01-01-1999 12/31/2006 1/18/1982 7/4/2010 ``` Für diese Feldwerte werden die folgenden Zeilen zurückgegeben. ``` 12-31-2006T00:00:00.000Z 01-18-1982T00:00:00.000Z 07-04-2010T00:00:00.000Z ``` # parseDecimal `parseDecimal` parst eine Zeichenfolge, um zu bestimmen, ob diese einen Dezimalwert enthält. Diese Funktion gibt alle Zeilen mit einem Dezimal-, Ganzzahl- oder Nullwert zurück und überspringt alle anderen. Enthält die Zeile einen Ganzzahlwert, wird dieser als Dezimalwert mit bis zu 4 Dezimalstellen zurückgegeben. Ein Wert von "2" wird beispielsweise als "2,0" zurückgegeben. ## Syntax ``` parseDecimal(expression) ``` ## Argumente *expression* Der Ausdruck muss eine Zeichenfolge sein. Es kann der Name eines Felds sein, das den Datentyp "string" verwendet, ein literaler Wert wie **'9.62'** oder der Aufruf einer Funktion, die eine Zeichenfolge ausgibt. ## Rückgabetyp Dezimalzahl (fest) in der älteren Datenaufbereitung. Dezimal (Float) in der neuen Datenaufbereitungserfahrung. ## Beispiel Im folgenden Beispiel wird `fee` ausgewertet, um zu bestimmen, ob Dezimalwerte enthalten sind. ``` parseDecimal(fee) ``` Das Feld enthält folgende Werte. ``` fee -------- 2 2a 12.13 3b 3.9 (null) 198.353398 ``` Für diese Feldwerte werden die folgenden Zeilen zurückgegeben. ``` 2.0 12.13 3.9 (null) 198.3533 ``` # parseInt `parseInt` parst eine Zeichenfolge, um zu bestimmen, ob diese einen Ganzzahlwert enthält. Diese Funktion gibt alle Zeilen mit einem Dezimal-, Ganzzahl- oder Nullwert zurück und überspringt alle anderen. Enthält die Zeile einen Dezimalwert, wird dieser auf die nächst niedrigere Ganzzahl abgerundet. Ein Wert von "2,99" wird beispielsweise als "2" zurückgegeben. ## Syntax ``` parseInt(expression) ``` ## Argumente *expression* Der Ausdruck muss eine Zeichenfolge sein. Es kann der Name eines Felds sein, das den Datentyp "string" verwendet, ein literaler Wert wie **'3'** oder der Aufruf einer Funktion, die eine Zeichenfolge ausgibt. ## Rückgabetyp Ganzzahl ## Beispiel Im folgenden Beispiel wird `feeType` ausgewertet, um zu bestimmen, ob Ganzzahlwerte enthalten sind. ``` parseInt(feeType) ``` Das Feld enthält folgende Werte. ``` feeType -------- 2 2.1 2a 3 3b (null) 5 ``` Für diese Feldwerte werden die folgenden Zeilen zurückgegeben. ``` 2 2 3 (null) 5 ``` # parseJson Verwenden Sie `parseJson` zum Extrahieren von Werten aus einem JSON-Objekt. Wenn Ihr Datensatz in Quick gespeichert istSPICE, können Sie ihn `parseJson` bei der Vorbereitung eines Datensatzes verwenden, jedoch nicht in berechneten Feldern während der Analyse. Für die direkte Abfrage können Sie `parseJson` während der Datenvorbereitung und während der Analyse verwenden. Die Funktion `parseJson` gilt für beide Zeichenfolgen oder native JSON-Datentypen (abhängig vom Dialekt), wie in der folgenden Tabelle dargestellt. | Dialekt | Typ | | --- | --- | | PostgreSQL | JSON | | Amazon Redshift | Zeichenfolge | | Microsoft SQL Server | Zeichenfolge | | MySQL | JSON | | Teradata | JSON | | Oracle | Zeichenfolge | | Presto | Zeichenfolge | | Snowflake | Halbstrukturiertes Datentypobjekt und -array | | Hive | Zeichenfolge | ## Syntax ``` parseJson(fieldName, path) ``` ## Argumente *fieldName* Das Feld mit dem JSON-Objekt, das Sie analysieren möchten. *path* Der Pfad zum Datenelement, das Sie aus dem JSON-Objekt analysieren wollen. Im Pfadargument werden nur Buchstaben, Zahlen und Leerzeichen unterstützt. Die gültige Pfadsyntax kann unter anderem wie folgt aussehen: + *\$1* — Stammobjekt + *.* – Untergeordneter Operator + *[]* – Index-Operator für Arrays ## Rückgabetyp Zeichenfolge ## Beispiel Das folgende Beispiel wertet eingehende JSON-Daten aus, um einen Wert für die Artikelmenge abzurufen. Durch dessen Verwendung während der Datenvorbereitung können Sie eine Tabelle aus den JSON-Daten erstellen. ``` parseJson({jsonField}, “$.items.qty”) ``` Nachfolgend ist der JSON-Text dargestellt. ``` { "customer": "John Doe", "items": { "product": "Beer", "qty": 6 }, "list1": [ "val1", "val2" ], "list2": [ { "list21key1": "list1value1" } ] } ``` In diesem Beispiel wird der folgende Wert zurückgegeben. ``` 6 ``` ## Beispiel Das folgende Beispiel wertet `JSONObject1` aus, um das erste Schlüssel-Wert-Paar (KVP) auszuwerten, das als `"State"` gekennzeichnet ist, und den Wert dem Kalkulationsfeld zuzuweisen, das Sie erstellen. ``` parseJson(JSONObject1, “$.state”) ``` Das Feld enthält folgende Werte. ``` JSONObject1 ----------- {"State":"New York","Product":"Produce","Date Sold":"1/16/2018","Sales Amount":"$3423.39"} {"State":"North Carolina","Product":"Bakery Products","Date Sold":"2/1/2018","Sales Amount":"$3226.42"} {"State":"Utah","Product":"Water","Date Sold":"4/24/2018","Sales Amount":"$7001.52"} ``` Für diese Feldwerte werden die folgenden Zeilen zurückgegeben. ``` New York North Carolina Utah ``` # Replace `replace` ersetzt einen Teil einer Zeichenfolge durch eine andere von Ihnen angegebene Zeichenfolge. ## Syntax ``` replace(expression, substring, replacement) ``` ## Argumente *expression* Der Ausdruck muss eine Zeichenfolge sein. Es kann der Name eines Felds sein, das den Datentyp "string" verwendet, ein literaler Wert wie **'12 Main Street'** oder der Aufruf einer Funktion, die eine Zeichenfolge ausgibt. *substring* Die Zeichen im *Ausdruck*, die Sie ersetzen möchten. Die Teilzeichenfolge kann sowohl einmal als auch mehrmals im *Ausdruck* enthalten sein. *replacement* Die Zeichenfolge, mit der Sie die *Teilzeichenfolge* ersetzt haben möchten. ## Rückgabetyp Zeichenfolge ## Beispiel Im folgenden Beispiel wird die Teilzeichenfolge "and" durch "or" ersetzt. ``` replace('1 and 2 and 3', 'and', 'or') ``` Die folgende Zeichenfolge wird zurückgegeben. ``` 1 or 2 or 3 ``` # Right `right` gibt das rechte Zeichen einer Zeichenfolge, einschließlich Leerzeichen, zurück. Sie geben die Anzahl der zurückzugebenden Zeichen an. ## Syntax ``` right(expression, limit) ``` ## Argumente *expression* Der Ausdruck muss eine Zeichenfolge sein. Es kann der Name eines Felds sein, das den Datentyp "string" verwendet, ein literaler Wert wie **'12 Main Street'** oder der Aufruf einer Funktion, die eine Zeichenfolge ausgibt. *limit* Die Anzahl der Zeichen, die vom *Ausdruck* zurückgegeben werden, beginnend mit dem letzten Zeichen der Zeichenfolge. ## Rückgabetyp Zeichenfolge ## Beispiel Im folgenden Beispiel werden die letzten fünf Zeichen einer Zeichenfolge zurückgegeben. ``` right('Seattle Store#14', 12) ``` Der folgende Wert wird zurückgegeben. ``` tle Store#14 ``` # Round `round` rundet einen Dezimalwert auf den nächsten Ganzzahlwert, wenn keine Skalierung angegeben ist, oder auf die nächste Dezimalstelle, wenn eine Skalierung angegeben ist. ## Syntax ``` round(decimal, scale) ``` ## Argumente *Dezimalwert* Ein Feld, das den Datentyp "decimal", einen literalen Wert wie **17.62** oder den Aufruf einer anderen Funktion verwendet, die einen Dezimalwert ausgibt. *scale* Die Anzahl der Dezimalstellen für die Rückgabewerte. ## Rückgabetyp | Operand | Geben Sie die Rückgabeart in der alten Datenaufbereitung ein | Geben Sie die neue Datenaufbereitungserfahrung ein | | --- | --- | --- | | INT | DEZIMAL (FEST) | DEZIMAL (FEST) | | DEZIMAL (FEST) | DEZIMAL (FEST) | DEZIMAL (FEST) | | DEZIMAL (FLOAT) | DEZIMAL (FEST) | DEZIMAL (FLOAT) | ## Beispiel Im folgenden Beispiel wird der Wert eines Dezimalfelds auf die nächstliegende zweite Dezimalstelle gerundet. ``` round(salesAmount, 2) ``` Das Feld enthält folgende Werte. ``` 20.1307 892.0388 57.5447 ``` Für diese Feldwerte werden die folgenden Ergebniswerte zurückgegeben. ``` 20.13 892.04 58.54 ``` # Rtrim `rtrim` entfernt nachgestellte Leerzeichen aus einer Zeichenfolge. ## Syntax ``` rtrim(expression) ``` ## Argumente *expression* Der Ausdruck muss eine Zeichenfolge sein. Es kann der Name eines Felds sein, das den Datentyp "string" verwendet, ein literaler Wert wie **'12 Main Street'** oder der Aufruf einer Funktion, die eine Zeichenfolge ausgibt. ## Rückgabetyp Zeichenfolge ## Beispiel Im folgenden Beispiel werden nachgestellte Leerzeichen aus einer Zeichenfolge entfernt. ``` rtrim('Seattle Store #14 ') ``` Für diese Feldwerte werden die folgenden Ergebniswerte zurückgegeben. ``` Seattle Store #14 ``` # Split `split` teilt eine Zeichenfolge anhand des festgelegten Trennzeichens in ein Array von Teilzeichenfolgen auf und gibt das Element an der angegebenen Position zurück. Sie können `split` während der Datenvorbereitung nur einem Kalkulationsfeld hinzufügen, nicht zu einer Analyse. Diese Funktion wird in direkten Abfragen an Microsoft SQL Server nicht unterstützt. ## Syntax ``` split(expression, delimiter , position) ``` ## Argumente *expression* Der Ausdruck muss eine Zeichenfolge sein. Es kann der Name eines Felds sein, das den Datentyp "string" verwendet, ein literaler Wert wie **'12 Main Street;1402 35th Ave;1818 Elm Ct;11 Janes Lane'** oder der Aufruf einer Funktion, die eine Zeichenfolge ausgibt. *delimiter* Das Zeichen, bei dessen Auftreten die übergebene Zeichenfolge in Teilzeichenfolgen aufgeteilt wird. Der Aufruf `split('one|two|three', '|', 2)` führt beispielsweise zu folgender Ausgabe. ``` one two three ``` Wenn Sie `position = 2` angeben, gibt `split` den Wert `'two'` zurück. *position* (Erforderlich) Die Position des zurückzugebenden Array-Elements. Die Position des ersten Elements im Array lautet 1. ## Rückgabetyp Zeichenfolgen-Array ## Beispiel Das folgende Beispiel teilt eine Zeichenfolge in ein Array auf und gibt dessen drittes Element zurück. Als Trennzeichen für die Aufteilung wird das Semikolon (;) verwendet. ``` split('123 Test St;1402 35th Ave;1818 Elm Ct;11 Janes Lane', ';', 3) ``` Das folgende Element wird zurückgegeben. ``` 1818 Elm Ct ``` Diese Funktion überspringt Elemente, die Nullwerte oder leere Zeichenfolgen enthalten. # Sqrt `sqrt` gibt die Quadratwurzel eines bestimmten Ausdrucks zurück. ## Syntax ``` sqrt(expression) ``` ## Argumente *expression* Der Ausdruck muss numerisch sein. Es kann sich um einen Feldnamen, einen literalen Wert oder eine andere Funktion handeln. # startsWith `startsWith` wertet aus, ob der Ausdruck mit einer von Ihnen angegebenen Teilzeichenfolge beginnt. Wenn der Ausdruck mit der Teilzeichenfolge beginnt, gibt `startsWith` „True“ zurück, andernfalls „false“. ## Syntax ``` startsWith(expression, substring, string-comparison-mode) ``` ## Argumente *expression* Der Ausdruck muss eine Zeichenfolge sein. Es kann der Name eines Felds sein, das den Datentyp "string" verwendet, ein literaler Wert wie **'12 Main Street'** oder der Aufruf einer Funktion, die eine Zeichenfolge ausgibt. *substring* Der Zeichensatz, der mit dem *Ausdruck* verglichen werden soll. Die Teilzeichenfolge kann sowohl einmal als auch mehrmals im *Ausdruck* enthalten sein. *string-comparison-mode* (Optional) Gibt den zu verwendenden Zeichenfolgenvergleichsmodus an: + `CASE_SENSITIVE` - Bei Zeichenfolgenvergleichen wird zwischen Groß- und Kleinschreibung unterschieden. + `CASE_INSENSITIVE` - Bei Zeichenfolgenvergleichen wird nicht zwischen Groß- und Kleinschreibung unterschieden. Dieser Wert wird standardmäßig auf `CASE_SENSITIVE` eingestellt, wenn er leer ist. ## Rückgabetyp Boolesch ## Beispiele ### Standardbeispiel für Groß- und Kleinschreibung Das folgende Beispiel, bei dem Groß- und Kleinschreibung berücksichtigt wird, bewertet, ob `state_nm` mit **New** startet. ``` startsWith(state_nm, "New") ``` Das Feld enthält folgende Werte. ``` New York new york ``` Für diese Feldwerte werden die folgenden Ergebniswerte zurückgegeben. ``` true false ``` ### Beispiel ohne Unterscheidung von Groß- und Kleinschreibung Im folgenden Beispiel ohne Unterscheidung von Groß- und Kleinschreibung wird ausgewertet, ob `state_nm` mit **new** startet. ``` startsWith(state_nm, "new", CASE_INSENSITIVE) ``` Das Feld enthält folgende Werte. ``` New York new york ``` Für diese Feldwerte werden die folgenden Ergebniswerte zurückgegeben. ``` true true ``` ### Beispiel mit bedingten Anweisungen Die `startsWith`-Funktion kann als bedingte Anweisung in den folgenden If-Funktionen verwendet werden: [avgIf](https://docs.aws.amazon.com/quicksight/latest/user/avgIf-function.html), [minIf](https://docs.aws.amazon.com/quicksight/latest/user/minIf-function.html), [distinct\$1countIf](https://docs.aws.amazon.com/quicksight/latest/user/distinct_countIf-function.html), [countIf](https://docs.aws.amazon.com/quicksight/latest/user/countIf-function.html), [maxIf](https://docs.aws.amazon.com/quicksight/latest/user/maxIf-function.html), [medianIf](https://docs.aws.amazon.com/quicksight/latest/user/medianIf-function.html), [stdevIf](https://docs.aws.amazon.com/quicksight/latest/user/stdevIf-function.html), [stdevpIf](https://docs.aws.amazon.com/quicksight/latest/user/stdevpIf-function.html), [sumIf](https://docs.aws.amazon.com/quicksight/latest/user/sumIf-function.html), [varIf](https://docs.aws.amazon.com/quicksight/latest/user/varIf-function.html) und [varpIf](https://docs.aws.amazon.com/quicksight/latest/user/varpIf-function.html). Das folgende Beispiel summiert `Sales` nur, wenn state\$1nm mit **New** beginnt. ``` sumIf(Sales,startsWith(state_nm, "New")) ``` ### Enthält KEIN Beispiel Der konditionale `NOT`-Operator kann verwendet werden, um auszuwerten, ob der Ausdruck nicht mit der angegebenen Teilzeichenfolge beginnt. ``` NOT(startsWith(state_nm, "New")) ``` ### Beispiel mit numerischen Werten Numerische Werte können in den Ausdrucks- oder Teilzeichenfolgenargumenten durch Anwendung der `toString`-Funktion verwendet werden. ``` startsWith(state_nm, toString(5) ) ``` # Strlen `strlen` gibt die Anzahl der Zeichen einer Zeichenfolge, einschließlich Leerstellen, zurück. ## Syntax ``` strlen(expression) ``` ## Argumente *expression* Ein Ausdruck kann der Name eines Felds sein, bei dem der Datentyp "string" verwendet wird, beispielsweise **address1**, ein literaler Wert wie **'Unknown'** oder eine andere Funktion wie `substring(field_name,0,5)`. ## Rückgabetyp Ganzzahl ## Beispiel Im folgenden Beispiel wird die Länge der angegebenen Zeichenfolge zurückgegeben. ``` strlen('1421 Main Street') ``` Der folgende Wert wird zurückgegeben. ``` 16 ``` # Substring `substring` gibt die Zeichen einer Zeichenfolge zurück. Dabei wird an der durch das *start*-Argument festgelegten Position begonnen und nach Erreichen der in den *length*-Argumenten angegebenen Anzahl an Zeichen aufgehört. ## Syntax ``` substring(expression, start, length) ``` ## Argumente *expression* Ein Ausdruck kann der Name eines Felds sein, bei dem der Datentyp "string" verwendet wird, beispielsweise **address1**, ein literaler Wert wie **'Unknown'** oder eine andere Funktion wie `substring(field_name,1,5)`. *start* Die Position für den Start. *start* ist inklusiv, das heißt, das Zeichen an der Startposition ist das erste Zeichen im zurückgegebenen Wert. Der Mindestwert für *Start* ist 1. *length* Die Anzahl der zusätzlichen Zeichen, die nach *start* eingeschlossen werden sollen. *length* schließt *start*, ein. Somit ist das letzte zurückgegebene Zeichen (*length* - 1) nach dem ersten Zeichen. ## Rückgabetyp Zeichenfolge ## Beispiel Im folgenden Beispiel werden die 13. bis 19. Zeichen einer Zeichenfolge zurückgegeben. Der Anfang der Zeichenfolge ist Index 1. Sie beginnen also beim ersten Zeichen zu zählen. ``` substring('Fantasy and Science Fiction',13,7) ``` Der folgende Wert wird zurückgegeben. ``` Science ``` # switch `switch` vergleicht einen *condition-expression (Bedingungsausdruck)* mit den literalen Bezeichnungen innerhalb einer Reihe von Kombinationen aus literalen Bezeichnungen und *Rückgabeausdrücken.* Anschließend wird der *return-expression (Rückgabeausdruck)* zurückgegeben, der der ersten literalen Bezeichnung entspricht, die dem *Bedingungsausdruck* entspricht. Wenn kein Label dem *condition-expression* (Bedingungsausdruck) entspricht, gibt `switch` *default-expression* (Standardausdruck) zurück. Jeder *return-expression* (Rückgabeausdruck) und jeder *default-expression* (Standardausdruck) müssen denselben Datentyp haben. ## Syntax ``` switch(condition-expression, label-1, return-expression-1 [, label-n, return-expression-n ...], default-expression) ``` ## Argumente `switch` erfordert mindestens ein oder mehrere *if*,*then*-Ausdruckspaar/e sowie genau einen Ausdruck für das *else*-Argument. *condition-expression* (Bedingungsausdruck) Der Ausdruck, der mit den label-literals (Labelliteralen) verglichen werden soll. Es kann sich dabei um einen Feldnamen wie `address`, einen literalen Wert wie „`Unknown`“ oder um eine sakalare Funktion wie `toString(salesAmount)` handeln. *Bezeichnung* Das Literal, das mit dem Argument *ondition-expression (Bedingungsausdruck)* verglichen werden soll. Alle Literale müssen denselben Datentyp wie das Argument *Bedingungsausdruck* haben. `switch` akzeptiert bis zu 5000 Bezeichnungen. *return-expressio* (Rückgabeausdruck) Der Ausdruck, der zurückgegeben werden soll, wenn der Wert seiner Bezeichnung dem Wert des *condition-expression* (Bedingungsausdrucks) entspricht. Es kann sich dabei um einen Feldnamen wie `address`, einen literalen Wert wie „`Unknown`“ oder um eine sakalare Funktion wie `toString(salesAmount)` handeln. Alle *return-expression*-Argumente müssen vom gleichen Datentyp wie alle *default-expression*-Argumente sein. *default-expression* (Standardausdruck) Der Ausdruck, der zurückgegeben werden soll, wenn kein Wert eines Bezeichungsarguments dem Wert des *condition-expression* (Bedingungsausdrucks) entspricht. Es kann sich dabei um einen Feldnamen wie `address`, einen literalen Wert wie „`Unknown`“ oder um eine sakalare Funktion wie `toString(salesAmount)` handeln. Der *default-expression* muss vom gleichen Datentyp wie alle *return-expression*-Argumente sein. ## Rückgabetyp `switch` gibt einen Wert desselben Typs wie die Werte in *return-expression* zurück. Alle Daten, die *return-expression* (Rückgabeausdruck) und *default-expression* (Standardausdruck) zurückgeben, müssen denselben Datentyp haben oder in denselben Datentyp konvertiert werden. ## Allgemeine Beispiele Das folgende Beispiel gibt den AWS-Region Code des Namens der Eingaberegion zurück. ``` switch(region_name, "US East (N. Virginia)", "us-east-1", "Europe (Ireland)", "eu-west-1", "US West (N. California)", "us-west-1", "other regions") ``` Das Feld enthält folgende Werte. ``` "US East (N. Virginia)" "US West (N. California)" "Asia Pacific (Tokyo)" ``` Für diese Feldwerte werden die folgenden Ergebniswerte zurückgegeben. ``` "us-east-1" "us-west-1" "other regions" ``` ## Verwenden Sie den Schalter zum Ersetzen von `ifelse` Der folgende Anwendungsfall `ifelse` entspricht dem vorherigen Beispiel, wobei `ifelse` bewertet, ob Werte eines Felds unterschiedlichen literalen Werten entsprechen, und `switch` stattdessen besser verwendet werden sollte. ``` ifelse(region_name = "US East (N. Virginia)", "us-east-1", region_name = "Europe (Ireland)", "eu-west-1", region_name = "US West (N. California)", "us-west-1", "other regions") ``` ## Ausdruck als Rückgabewert Das folgende Beispiel verwendet Ausdrücke in *return-expressions* (Rückgabeausdrücken): ``` switch({origin_city_name}, "Albany, NY", {arr_delay} + 20, "Alexandria, LA", {arr_delay} - 10, "New York, NY", {arr_delay} * 2, {arr_delay}) ``` Im vorherigen Beispiel wird die erwartete Verspätungszeit für jeden Flug aus einer bestimmten Stadt geändert. ![\[Ein Image der Ergebnisse des Funktionsbeispiels in Tabellenform.\]](http://docs.aws.amazon.com/de_de/quick/latest/userguide/images/switch-function-example.png) # toLower `toLower` formatiert Zeichenkette in Kleinbuchstaben. `toLower` überspringt Zeilen mit Nullwerten. ## Syntax ``` toLower(expression) ``` ## Argumente *expression* Der Ausdruck muss eine Zeichenfolge sein. Es kann der Name eines Felds sein, das den Datentyp "string" verwendet, ein literaler Wert wie **'12 Main Street'** oder der Aufruf einer Funktion, die eine Zeichenfolge ausgibt. ## Rückgabetyp Zeichenfolge ## Beispiel Im folgenden Beispiel wird ein Zeichenfolgenwert in Kleinbuchstaben konvertiert. ``` toLower('Seattle Store #14') ``` Der folgende Wert wird zurückgegeben. ``` seattle store #14 ``` # toString `toString` formatiert die Ausgangszeichenfolge als String. `toString` überspringt Zeilen, die Nullwerte enthalten. ## Syntax ``` toString(expression) ``` ## Argumente *expression* Ein Ausdruck kann ein Feld eines beliebigen Datentyps sein, ein literaler Wert wie **14.62** oder der Aufruf einer anderen Funktion, die einen beliebigen Datentyp zurückgibt. ## Rückgabetyp Zeichenfolge ## Beispiel Im folgenden Beispiel werden die Werte von `payDate` (dem der Datentyp `date` zugewiesen ist) als Zeichenfolgen zurückgegeben. ``` toString(payDate) ``` Das Feld enthält folgende Werte. ``` payDate -------- 1992-11-14T00:00:00.000Z 2012-10-12T00:00:00.000Z 1973-04-08T00:00:00.000Z ``` Für diese Feldwerte werden die folgenden Zeilen zurückgegeben. ``` 1992-11-14T00:00:00.000Z 2012-10-12T00:00:00.000Z 1973-04-08T00:00:00.000Z ``` # toUpper `toUpper` formatiert eine Zeichenkette in Großbuchstaben. `toUpper` überspringt Zeilen mit Nullwerten. ## Syntax ``` toUpper(expression) ``` ## Argumente *expression* Der Ausdruck muss eine Zeichenfolge sein. Es kann der Name eines Felds sein, das den Datentyp "string" verwendet, ein literaler Wert wie **'12 Main Street'** oder der Aufruf einer Funktion, die eine Zeichenfolge ausgibt. ## Rückgabetyp Zeichenfolge ## Beispiel Im folgenden Beispiel wird ein Zeichenfolgenwert in Großbuchstaben konvertiert. ``` toUpper('Seattle Store #14') ``` Der folgende Wert wird zurückgegeben. ``` SEATTLE STORE #14 ``` # trim `trim` entfernt sowohl vorangestellte als auch nachfolgende Leerzeichen aus einer Zeichenfolge. ## Syntax ``` trim(expression) ``` ## Argumente *expression* Der Ausdruck muss eine Zeichenfolge sein. Es kann der Name eines Felds sein, das den Datentyp "string" verwendet, ein literaler Wert wie **'12 Main Street'** oder der Aufruf einer Funktion, die eine Zeichenfolge ausgibt. ## Rückgabetyp Zeichenfolge ## Beispiel Im folgenden Beispiel werden nachgestellte Leerzeichen aus einer Zeichenfolge entfernt. ``` trim(' Seattle Store #14 ') ``` Für diese Feldwerte werden die folgenden Ergebniswerte zurückgegeben. ``` Seattle Store #14 ``` # truncDate `truncDate` gibt einen Datumswert zurück, der einen bestimmten Teil eines Datums darstellt. Beispiel: Wird der Jahresteil des Werts 2012-09-02T00:00:00.000Z abgerufen, wird 2012-01-01T00:00:00.000Z zurückgegeben. Die Angabe eines Uhrzeit-bezogenen Teils eines Datums, das keine Zeitinformationen enthält, führt dazu, dass der ursprüngliche Datumswert unverändert zurückgegeben wird. ## Syntax ``` truncDate('period', date) ``` ## Argumente *Zeitraum* Der Zeitraum des Datums, der zurückgegeben werden soll. Folgende Zeiträume werden unterstützt: + YYYY: Gibt den Jahresteil des Datums zurück. + Q: Gibt das Datum des ersten Tags des Quartals zurück, in das das Datum fällt. + MM: Gibt den Monatsteil des Datums zurück. + DD: Gibt den Tagesteil des Datums zurück. + WK: Gibt den Wochenteil des Datums zurück. Die Woche beginnt am Sonntag in Amazon Quick. + HH: Gibt den Stundenteil des Datums zurück. + MI: Gibt den Minutenteil des Datums zurück. + SS: Gibt den Sekundenteil des Datums zurück. + SS: Gibt den Sekundenteil des Datums zurück. *date* Ein Datumsfeld oder der Aufruf einer anderen Funktion, die ein Datum ausgibt. ## Rückgabetyp Date ## Beispiel Im folgenden Beispiel wird ein Datum zurückgegeben, aus dem der Monat des Bestelldatums hervorgeht. ``` truncDate('MM', orderDate) ``` Das Feld enthält folgende Werte. ``` orderDate ========= 2012-12-14T00:00:00.000Z 2013-12-29T00:00:00.000Z 2012-11-15T00:00:00.000Z ``` Für diese Feldwerte werden die folgenden Ergebniswerte zurückgegeben. ``` 2012-12-01T00:00:00.000Z 2013-12-01T00:00:00.000Z 2012-11-01T00:00:00.000Z ```