Verwalten von Array- und Zuordnungsdatentypen mit Funktionen mit höherer Reihenfolge
In diesem Handbuch erfahren Sie, wie Funktionen mit höherer Reihenfolge komplexe Datentypen verarbeiten können, wie Arrays und Maps. Diese Funktionen entfernen die Notwendigkeit, das Array zu explodieren, eine Funktion auszuführen und dann das Ergebnis zu kombinieren. Funktionen mit höherer Reihenfolge sind besonders nützlich für die Analyse oder Verarbeitung von Datensätzen und Analysen in Zeitreihen, die häufig komplexe verschachtelte Strukturen, Arrays, Karten und verschiedene Anwendungsfälle enthalten.
Die folgende Liste von Anwendungsfällen enthält Beispiele für Funktionen zur Bearbeitung von Array- und Zuordnungen höherer Reihenfolge.
Verwenden Sie die Umwandlung, um die Preissumme um n anzupassen. adjust-price-total
transform(array<T>, function<T, U>): array<U>
Das obige Snippet wendet eine Funktion auf jedes Element des Arrays an und gibt ein neues Array transformierter Elemente zurück. Die Funktion transform nimmt ein Array des Typs T und konvertiert jedes Element vom Typ T in den Typ U. Anschließend wird ein Array des Typs U zurückgegeben. Die tatsächlichen Typen T und U hängen von der spezifischen Verwendung der Transformationsfunktion ab.
transform(array<T>, function<T, Int, U>): array<U>
Diese Array-Umwandlungsfunktion ähnelt dem vorherigen Beispiel, es gibt jedoch zwei Argumente für die Funktion . Das zweite Argument in dieser Funktion erhält zusätzlich zur Umwandlung auch den Index des Elements im Array.
Beispiel
Das folgende SQL-Beispiel zeigt diesen Anwendungsfall. Die Abfrage ruft eine begrenzte Anzahl von Zeilen aus der angegebenen Tabelle ab und wandelt das Array productListItems um, indem das Attribut priceTotal jedes Elements mit 73 multipliziert wird. Das Ergebnis umfasst die Spalten _id, productListItems und die umgewandelten price_in_inr. Die Auswahl basiert auf einem bestimmten Zeitstempelbereich.
SELECT _id,
productListItems,
Transform(productListItems, value -> value.priceTotal * 73) AS
price_in_inr
FROM geometrixxx_999_xdm_pqs_1batch_10k_rows
WHERE timestamp > To_timestamp('2017-11-01 00:00:00')
AND timestamp < To_timestamp('2017-11-02 00:00:00')
LIMIT 10;
Ergebnis
Die Ergebnisse für diese SQL würden den unten aufgeführten ähneln.
productListItems | price_in_inr
-------------------+----------------
(8376, NULL, NULL) | 611448.0
{(Burbank Hills Jeans, NULL, NULL), (Thermomax Steel, NULL, NULL), (Bruin Point Shearling Boots, NULL, NULL), (Uintas Pro Ski Gloves, NULL, NULL), (Timberline Survival Knife, NULL, NULL), (Thermomax Steel, NULL, NULL), (Timpanogos Scarf, NULL, NULL), (Lost Prospector Beanie, NULL, NULL), (Timpanogos Scarf, NULL, NULL), (Uintas Pro Ski Gloves, NULL, NULL)} | {0.0,0.0.0.0,0,0,0,0,0,0,0,0,0,0,0,0,0.0}
(84763,NULL, NULL) | 6187699.0
(843765, NULL, NULL) | 6.1594845E7
(199684, NULL, NULL) | 1.4576932E7
(10 rows)
Verwendung vorhanden, um zu ermitteln, ob ein Produkt mit einer bestimmten SKU vorhanden ist confirm-product-exists
exists(array<T>, function<T, boolean>): boolean
Im obigen Ausschnitt wird die Funktion exists auf jedes Element des Arrays angewendet und gibt einen booleschen Wert zurück. Der boolesche Wert gibt an, ob ein oder mehrere Elemente im Array vorhanden sind, die eine bestimmte Bedingung erfüllen. In diesem Fall wird bestätigt, ob ein Produkt mit einer bestimmten SKU vorhanden ist.
Beispiel
Im folgenden SQL-Beispiel ruft die Abfrage productListItems aus der Tabelle geometrixxx_999_xdm_pqs_1batch_10k_rows ab und bewertet, ob ein Element mit einer SKU von 123679 im Array productListItems vorhanden ist. Anschließend werden die Ergebnisse anhand eines bestimmten Zeitstempelbereichs gefiltert und die endgültigen Ergebnisse auf zehn Zeilen beschränkt.
SELECT productListItems
FROM geometrixxx_999_xdm_pqs_1batch_10k_rows
WHERE EXISTS( productListItems, value -> value.sku == 123679)
AND timestamp > to_timestamp('2017-11-01 00:00:00')
AND timestamp < to_timestamp('2017-11-02 00:00:00')limit 10;
Ergebnis
Die Ergebnisse für diese SQL würden den unten aufgeführten ähneln.
productListItems
-----------------
{(123679, NULL,NULL)}
{(123679, NULL, NULL)}
{(123679, NULL, NULL), (150196, NULL, NULL)}
{(123679, NULL, NULL), (150196, NULL, NULL)}
{(123679, NULL, NULL), (150196, NULL, NULL)}
{(123679, NULL, NULL)}
{(123679, NULL, NULL)}
{(123679, NULL, NULL)}
{(123679, NULL,NULL)}
{(123679,NULL, NULL)}
(10 rows)
Verwenden Sie Filter, um Produkte mit einer SKU > 100000 zu finden. find-specific-products
filter(array<T>, function<T, boolean>): array<T>
Diese Funktion filtert ein Array von Elementen basierend auf einer gegebenen Bedingung, die jedes Element als booleschen Wert auswertet. Anschließend wird ein neues Array zurückgegeben, das nur Elemente enthält, bei denen die Bedingung den Wert "true"zurückgab.
Beispiel
In der folgenden Abfrage wird die Spalte productListItems ausgewählt, ein Filter angewendet, um nur Elemente mit einer SKU von mehr als 10000 einzuschließen und der Ergebnissatz auf Zeilen innerhalb eines bestimmten Zeitstempelbereichs beschränkt. Das gefilterte Array wird dann in der Ausgabe als _filter Alias genannt.
SELECT productListItems,
Filter(productListItems, value -> value.sku > 100000) AS _filter
FROM geometrixxx_999_xdm_pqs_1batch_10k_rows
WHERE timestamp > To_timestamp('2017-11-01 00:00:00')
AND timestamp < To_timestamp('2017-11-02 00:00:00')
LIMIT 10;
Ergebnis
Die Ergebnisse für diese SQL würden den unten aufgeführten ähneln.
productListItems | _filter
-----------------+---------
(123679, NULL, NULL) (123679, NULL, NULL)
(1346, NULL, NULL) |
(98347, NULL, NULL) |
(176015, NULL, NULL) | (176015, NULL, NULL)
(10 rows)
Verwenden Sie Aggregat, um die SKUs aller Produktlistenelemente zu summieren, die mit einer bestimmten ID verknüpft sind, und verdoppeln Sie die resultierende Gesamtsumme sum-specific-skus-and-double-the-resulting-total
aggregate(array<T>, A, function<A, T, A>[, function<A, R>]): R
Dieser Aggregat-Vorgang wendet einen binären Operator auf einen Anfangsstatus und alle Elemente im Array an. Außerdem werden mehrere Werte auf einen einzigen Status reduziert. Nach dieser Verringerung wird der endgültige Status mithilfe einer Finish-Funktion in das endgültige Ergebnis konvertiert. Die Finish-Funktion nimmt den letzten Status an, der nach Anwendung des binären Operators auf alle Array-Elemente erhalten wurde, und führt mit ihr eine Aktion durch, um das endgültige Ergebnis zu erzielen.
Beispiel
In diesem Abfragebeispiel wird der maximale SKU-Wert aus dem productListItems -Array innerhalb des angegebenen Zeitstempelbereichs berechnet und das Ergebnis verdoppelt. Die Ausgabe enthält das ursprüngliche productListItems -Array und den berechneten max_value.
SELECT productListItems,
aggregate(productListItems, 0, (acc, value) ->
case
WHEN (
value.sku > acc) THEN cast(value.sku AS int)
ELSE cast(acc AS int)
END, acc -> acc * 2) AS max_value
FROM geometrixxx_999_xdm_pqs_1batch_10k_rows
WHERE timestamp > to_timestamp('2017-11-01 00:00:00')
AND timestamp < to_timestamp('2017-11-02 00:00:00')
LIMIT 50;
Ergebnis
Die Ergebnisse für diese SQL würden den unten aufgeführten ähneln.
productListItems | max_value
-----------------+---------
(123679, NULL, NULL) | 247358
(1346,NULL, NULL) | 2692
(98347, NULL, NULL) | 196694
(176015, NULL, NULL) | 352030
(10 rows)
Verwenden Sie zip_with , um allen Elementen in der Produktliste eine Sequenznummer zuzuweisen. assign-a-sequence-number
zip_with(array<T>, array<U>, function<T, U, R>): array<R>
Dieses Snippet kombiniert die Elemente zweier Arrays in einem neuen Array. Der Vorgang wird unabhängig für jedes Element des Arrays ausgeführt und generiert Wertepaare. Wenn ein Array kürzer ist, werden Nullwerte hinzugefügt, die mit der Länge des längeren Arrays übereinstimmen. Dies geschieht, bevor die Funktion angewendet wird.
Beispiel
Die folgende Abfrage verwendet die Funktion zip_with , um aus zwei Arrays Wertepaare zu erstellen. Dazu werden die SKU-Werte aus dem productListItems -Array einer Ganzzahlsequenz hinzugefügt, die mithilfe der Funktion Sequence generiert wurde. Das Ergebnis wird neben der ursprünglichen Spalte productListItems ausgewählt und ist basierend auf einem Zeitstempelbereich begrenzt.
SELECT productListItems,
zip_with(Sequence(1,5), Transform(productListItems, p -> p.sku), (x,y) -> struct(x, y)) AS zip_with
FROM geometrixxx_999_xdm_pqs_1batch_10k_rows
WHERE timestamp > to_timestamp('2017-11-01 00:00:00')
AND timestamp < to_timestamp('2017-11-02 00:00:00')
limit 10;
Ergebnis
Die Ergebnisse für diese SQL würden den unten aufgeführten ähneln.
productListItems | zip_with
---------------------+---------
| {(1,NULL), (2,NULL), (3,NULL),(4,NULL), (5,NULL)}
(123679, NULL, NULL) | {(1,123679), (2,NULL), (3,NULL), (4,NULL), (5,NULL)}
| {(1,NULL), (2,NULL),(3,NULL),(4,NULL), (5,NULL)}
| {(1,NULL), (2,NULL), (3, NULL),(4,NULL), (5,NULL)}
(1346,NULL, NULL) | {(1,1346), (2,NULL),(3,NULL),(4,NULL), (5,NULL)}
| {(1,NULL), (2,NULL), (3,NULL),(4,NULL), (5,NULL)}
(98347, NULL, NULL) | {(1,98347), (2,NULL), (3,NULL), (4,NULL), (5,NULL)}
| {(1,NULL), (2,NULL), (3,NULL), (4,NULL), (5,NULL)}
(176015, NULL, NULL) | {(1,176015),(2,NULL), (3,NULL), (4,NULL), (5,NULL)}
| {(1,NULL), (2,NULL), (3,NULL), (4,NULL), (5,NULL)}
(10 rows)
Verwenden Sie map_from_tries, um jedem Element in der Produktliste eine Sequenznummer zuzuweisen und das endgültige Ergebnis als Zuordnung zu erhalten. assign-a-sequence-number-return-result-as-map
map_from_entries(array<struct<K, V>>): map<K, V>
Dieses Snippet konvertiert ein Array von Schlüssel-Wert-Paaren in eine Zuordnung. Dies ist nützlich, wenn es um Schlüssel-Wert-Paardaten geht, die von einer besser organisierten und effizienteren Struktur profitieren könnten.
Beispiel
Die folgende Abfrage erstellt Wertepaare aus einer Sequenz und dem productListItems-Array, konvertiert diese Paare mithilfe von map_from_tries in eine Zuordnung und wählt dann die ursprüngliche Spalte productListItems zusammen mit der neu erstellten Spalte map_from_tries aus. Das Ergebnis wird basierend auf dem angegebenen Zeitstempelbereich gefiltert und begrenzt.
SELECT productListItems, map_from_entries(zip_with(Sequence(1,Size(productListItems)), productListItems, (x,y) -> struct(x, y))) AS map_from_entries
FROM geometrixxx_999_xdm_pqs_1batch_10k_rows
WHERE timestamp > to_timestamp('2017-11-01 00:00:00')
AND timestamp < to_timestamp('2017-11-02 00:00:00')
LIMIT 10;
Ergebnis
Die Ergebnisse für diese SQL würden den unten aufgeführten ähneln.
productListItems | map_from_entries
---------------------+------------------
(123679, NULL, NULL) | [1 -> "(123679,NULL,NULL)"]
(1346, NULL, NULL) | [1 -> "(1346, NULL, NULL)"]
(98347, NULL, NULL) | [1 -> "(98347, NULL, NULL)"]
(176015, NULL, NULL) | [1 -> "(176015, NULL, NULL)"]
(92763, NULL, NULL) | [1 -> "(92763, NULL, NULL)"]
(48576, NULL, NULL) | [1 -> "(48576, NULL, NULL)"]
(135778, NULL, NULL) | [1 -> "(135778, NULL, NULL)"]
(123679, NULL, NULL) | [1 -> "(123679, NULL, NULL)"]
(98347, NULL, NULL) | [1 -> "(98347, NULL, NULL)"]
(167753, NULL, NULL) | [1 -> "(167753, NULL, NULL)"]
(10 rows)
Verwenden Sie map_form_arrays , um den Elementen in der Produktliste Sequenznummern zuzuweisen und das Ergebnis als Zuordnung zurückzugeben. assign-sequence-numbers-to-items-return-the-result-as-a-map
map_form_arrays(array<K>, array<V>): map<K, V>
Die Funktion map_form_arrays erstellt eine Zuordnung, die paarweise Werte aus zwei Arrays verwendet.
Beispiel
Die nachstehende SQL erstellt eine Zuordnung, bei der die Schlüssel sequenzierte Zahlen sind, die mit der Funktion Sequence generiert werden, und die Werte Elemente aus dem Array productListItems sind. Die Abfrage wählt die Spalte productListItems aus und erstellt mithilfe der Funktion Map_from_arrays die Zuordnung basierend auf der generierten Zahlenfolge und den Elementen des Arrays. Das Ergebnis ist auf zehn Zeilen begrenzt und wird anhand eines Zeitstempelbereichs gefiltert.
SELECT productListItems,
Map_from_arrays(Sequence(1, Size(productListItems)), productListItems) AS
map_from_arrays
FROM geometrixxx_999_xdm_pqs_1batch_10k_rows
WHERE Size(productListItems) > 0
AND timestamp > To_timestamp('2017-11-01 00:00:00')
AND timestamp < To_timestamp('2017-11-02 00:00:00')
LIMIT 10;
Ergebnis
Die Ergebnisse für diese SQL würden den unten aufgeführten ähneln.
productListItems | map_from_entries
---------------------+------------------
(123679, NULL, NULL) | [1 -> "(123679,NULL,NULL)"]
(1346, NULL, NULL) | [1 -> "(1346, NULL, NULL)"]
(98347, NULL, NULL) | [1 -> "(98347, NULL, NULL)"]
(176015, NULL, NULL) | [1 -> "(176015, NULL, NULL)"]
(92763, NULL, NULL) | [1 -> "(92763, NULL, NULL)"]
(48576, NULL, NULL) | [1 -> "(48576, NULL, NULL)"]
(135778, NULL, NULL) | [1 -> "(135778, NULL, NULL)"]
(123679, NULL, NULL) | [1 -> "(123679, NULL, NULL)"]
(98347, NULL, NULL) | [1 -> "(98347, NULL, NULL)"]
(167753, NULL, NULL) | [1 -> "(167753, NULL, NULL)"]
(10 rows)
Verwenden Sie map_concat , um zwei Maps als einzelne Zuordnung zu verketten. concatenate-two-maps-into-as-single-map
map_concat(map<K, V>, ...): map<K, V>
Die Funktion map_concat im obigen Codefragment akzeptiert mehrere Maps als Argumente und gibt eine neue Zuordnung zurück, die alle Schlüssel-Wert-Paare aus den Eingabemaps kombiniert. Die Funktion verkettet mehrere Maps in einer Zuordnung, und die resultierende Zuordnung enthält alle Schlüssel-Wert-Paare aus den Eingabemaps.
Beispiel
Die nachstehende SQL erstellt eine Zuordnung, bei der jedes Element in productListItems mit einer Sequenznummer verknüpft ist, die dann mit einer anderen Zuordnung verkettet wird, bei der Schlüssel in einem bestimmten Sequenzbereich generiert werden.
SELECT productListItems,
map_concat(
map_from_entries(zip_with(Sequence(1,Size(productListItems)), productListItems, (x,y) -> struct(x, y))),
map_from_arrays(sequence(size(productListItems) + 1, size(productListItems) + size(productListItems)), productListItems) )
FROM geometrixxx_999_xdm_pqs_1batch_10k_rows
WHERE size(productListItems) > 0
AND timestamp > to_timestamp('2017-11-01 00:00:00')
AND timestamp < to_timestamp('2017-11-02 00:00:00')
limit 10;
Ergebnis
Die Ergebnisse für diese SQL würden den unten aufgeführten ähneln.
productListItems | map_from_entries
---------------------+------------------
(123679, NULL, NULL) | [1 -> "(123679,NULL,NULL)",2 -> "(123679, NULL, NULL)"]
(1346, NULL, NULL) | [1 -> "(1346, NULL, NULL)",2 -> "(1346, NULL, NULL)"]
(98347, NULL, NULL) | [1 -> "(98347, NULL, NULL)",2 -> "(98347, NULL, NULL)"]
(176015, NULL, NULL) | [1 -> "(176015, NULL, NULL)",2 -> "(176015, NULL, NULL)"]
(92763, NULL, NULL) | [1 -> "(92763, NULL, NULL)",2 -> "(92763, NULL, NULL)"]
(48576, NULL, NULL) | [1 -> "(48576, NULL, NULL)",2 -> "(48576, NULL, NULL)"]
(135778, NULL, NULL) | [1 -> "(135778, NULL, NULL)",2 -> "(135778, NULL, NULL)"]
(123679, NULL, NULL) | [1 -> "(123679, NULL, NULL)",2 -> "(123679, NULL, NULL)"]
(98347, NULL, NULL) | [1 -> "(98347, NULL, NULL)",2 -> "(98347, NULL, NULL)"]
(167753, NULL, NULL) | [1 -> "(167753, NULL, NULL)",2 -> "(167753, NULL, NULL)"]
(10 rows)
Verwenden Sie element_at, um einen Wert abzurufen, der "AAID"in der Identitätszuordnung für die weitere Berechnung entspricht. retrieve-a-corresponding-value
element_at(array<T>, Int): T / element_at(map<K, V>, K): V
Bei Arrays gibt das Snippet das Element an einem angegebenen (1-basierten) Index oder den Wert zurück, der einem Schlüssel in einer Zuordnung zugeordnet ist. Wenn der Index < 0 ist, greift er auf Elemente vom letzten zum ersten zu und gibt null zurück, wenn der Index die Länge des Arrays überschreitet.
Bei Maps wird entweder ein Wert für den angegebenen Schlüssel zurückgegeben oder null, wenn der Schlüssel nicht in der Zuordnung enthalten ist.
Beispiel
Die Abfrage wählt die Spalte identitymap aus der Tabelle geometrixxx_999_xdm_pqs_1batch_10k_rows aus und extrahiert für jede Zeile den Wert, der dem Schlüssel AAID zugeordnet ist. Die Ergebnisse sind auf Zeilen beschränkt, die innerhalb des angegebenen Zeitstempelbereichs liegen, und die Abfrage beschränkt die Ausgabe auf zehn Zeilen.
SELECT identitymap,
Element_at(identitymap, 'AAID')
FROM geometrixxx_999_xdm_pqs_1batch_10k_rows
WHERE timestamp > To_timestamp('2017-11-01 00:00:00')
AND timestamp < To_timestamp('2017-11-02 00:00:00')
LIMIT 10;
Ergebnis
Die Ergebnisse für diese SQL würden den unten aufgeführten ähneln.
identitymap | element_at(identitymap, AAID)
-------------------------------------------------------------------------------------------------------------------------+-------------------------------------
[AAID -> "(3617FBB942466D79-5433F727AD6A0AD, false)",ECID -> "(67383754798169392543508586197135045866,true)"] | (3617FBB942466D79-5433F727AD6A0AD, false)
[AAID -> "[AAID -> "(533F56A682C059B1-396437F68879F61D, false)",ECID -> "(91989370462250197735311833131353001213,true)"] | (533F56A682C059B1-396437F68879F61D, false)
[AAID -> "(22E195F8A8ECCC6A-A39615C93B72A9F, false)",ECID -> "(57699241367342030964647681192998909474,true)"] | (22E195F8A8ECCC6A-A39615C93B72A9F, false)
[AAID -> "(6A60527B9D66CCB9-29638A632B45E9, false)",ECID -> "(50117234882064422833184021414056250576,true)"] | (6A60527B9D66CCB9-29638A632B45E9, false)
[AAID -> "(64FB4DC317E21B59-2A23602D234647E7, false)",ECID -> "(79785479785408621882908938960039330887,true)"] | (64FB4DC317E21B59-2A23602D234647E7, false)
[AAID -> "(2E70E8CF6DB1DE86-270E55BBBA58B9C1, false)",ECID -> "(80073674009951685326146914344189474476,true)"] | (2E70E8CF6DB1DE86-270E55BBBA58B9C1, false)
[AAID -> "(22E195F8A8ECCC6A-A39615C93B72A9F, false)",ECID -> "(57699241367342030964647681192998909474,true)"] | (22E195F8A8ECCC6A-A39615C93B72A9F, false)
[AAID -> "(1CFB3297C3146F2F-28D6902A610BA3B1, false)",ECID -> "(88251082790399360979074868101758236669,true)"] | (1CFB3297C3146F2F-28D6902A610BA3B1, false)
[AAID -> "(533F56A682C059B1-396437F68879F61D, false)",ECID -> "(91989370462250197735311833131353001213,true)"] | (533F56A682C059B1-396437F68879F61D, false)
(10 rows)
Kardinalität verwenden, um die Anzahl der Identitäten in der Identitätszuordnung zu ermitteln find-the-number-of-identities-in-the-identity-map
cardinality(array<T>): Int / cardinality(map<K, V>): Int
Dieses Snippet gibt die Größe eines angegebenen Arrays oder einer gegebenen Zuordnung zurück und stellt einen Alias bereit. Gibt -1 zurück, wenn der Wert null ist.
Beispiel
Die folgende Abfrage ruft die Spalte identitymap ab und die Funktion Cardinality berechnet die Anzahl der Elemente in jeder Zuordnung innerhalb der identitymap. Die Ergebnisse sind auf zehn Zeilen beschränkt und werden anhand eines festgelegten Zeitstempelbereichs gefiltert.
SELECT identitymap,
Cardinality(identitymap)
FROM geometrixxx_999_xdm_pqs_1batch_10k_rows
WHERE timestamp > To_timestamp('2017-11-01 00:00:00')
AND timestamp < To_timestamp('2017-11-02 00:00:00')
LIMIT 10;
Ergebnis
Die Ergebnisse für diese SQL würden den unten aufgeführten ähneln.
identitymap | size(identitymap)
-------------------------------------------------------------------------------------------------------------------------+-------------------------------------
[AAID -> "(3617FBB942466D79-5433F727AD6A0AD, false)",ECID -> "(67383754798169392543508586197135045866,true)"] | 2
[AAID -> "[AAID -> "(533F56A682C059B1-396437F68879F61D, false)",ECID -> "(91989370462250197735311833131353001213,true)"] | 2
[AAID -> "(22E195F8A8ECCC6A-A39615C93B72A9F, false)",ECID -> "(57699241367342030964647681192998909474,true)"] | 2
[AAID -> "(6A60527B9D66CCB9-29638A632B45E9, false)",ECID -> "(50117234882064422833184021414056250576,true)"] | 2
[AAID -> "(64FB4DC317E21B59-2A23602D234647E7, false)",ECID -> "(79785479785408621882908938960039330887,true)"] | 2
[AAID -> "(2E70E8CF6DB1DE86-270E55BBBA58B9C1, false)",ECID -> "(80073674009951685326146914344189474476,true)"] | 2
[AAID -> "(22E195F8A8ECCC6A-A39615C93B72A9F, false)",ECID -> "(57699241367342030964647681192998909474,true)"] | 2
[AAID -> "(1CFB3297C3146F2F-28D6902A610BA3B1, false)",ECID -> "(88251082790399360979074868101758236669,true)"] | 2
[AAID -> "(533F56A682C059B1-396437F68879F61D, false)",ECID -> "(91989370462250197735311833131353001213,true)"] | 2
(10 rows)
Verwenden Sie array_distinct , um die einzelnen Elemente in productListItems zu finden. find-distinct-elements
array_distinct(array<T>): array<T>
Der obige Ausschnitt entfernt doppelte Werte aus dem angegebenen Array.
Beispiel
In der folgenden Abfrage werden die Spalte productListItems ausgewählt, doppelte Elemente aus den Arrays entfernt und die Ausgabe auf zehn Zeilen basierend auf einem angegebenen Zeitstempelbereich beschränkt.
SELECT productListItems,
Array_distinct(productListItems)
FROM geometrixxx_999_xdm_pqs_1batch_10k_rows
WHERE timestamp > To_timestamp('2017-11-01 00:00:00')
AND timestamp < To_timestamp('2017-11-02 00:00:00')
LIMIT 10;
Ergebnis
Die Ergebnisse für diese SQL würden den unten aufgeführten ähneln.
productListItems | array_distinct(productListItems)
---------------------+---------------------------------
|
(123679, NULL, NULL) | (123679, NULL, NULL)
|
|
(1346,NULL, NULL) | (1346,NULL, NULL)
|
(98347, NULL, NULL) | (98347, NULL, NULL)
|
(176015, NULL, NULL) | (176015, NULL, NULL)
|
(10 rows)
Zusätzliche Funktionen mit höherer Reihenfolge additional-higher-order-functions
Die folgenden Beispiele für Funktionen mit höherer Reihenfolge werden im Anwendungsbeispiel zum Abrufen ähnlicher Datensätze erläutert. Ein Beispiel und eine Erläuterung der Verwendung jeder Funktion finden Sie im entsprechenden Abschnitt dieses Dokuments.
Das Funktionsbeispiel transform umfasst die Tokenisierung einer Produktliste.
Das Funktionsbeispiel filter zeigt eine verfeinerte und präzisere Extraktion relevanter Informationen aus Textdaten.
Die Funktion reducebietet eine Möglichkeit, kumulative Werte oder Aggregate abzuleiten, die in verschiedenen Analyse- und Planungsprozessen ausschlaggebend sein können.