Riferimento per gli operatori di funzione tabella

L'operatore di funzione tabella fornisce un elenco di funzioni tabella incorporate che è possibile utilizzare in un flusso di dati per restituire i dati sotto forma di tabelle.

Vedere Table Function Operator.

Di seguito è riportato un elenco delle funzioni tabella incorporate supportate dall'operatore della funzione tabella.

Cache

Rende persistente e memorizza nella cache un set di dati in base alla memoria specificata level.

Restituisce un nuovo data set nel data set distribuito resiliente memorizzato nella cache (RDD).


Parametro	descrizione;
`level`	Memoria da utilizzare: `MEMORY_ONLY`: consente di memorizzare come oggetti Java deserializzati nella JVM. Se la memoria è insufficiente, alcune partizioni RDD non vengono inserite nella cache, ma vengono ricalcolate come e quando necessario. `MEMORY_AND_DISK`: consente di memorizzare come oggetti Java deserializzati nella JVM. Se la memoria è insufficiente, alcune partizioni RDD vengono memorizzate sul disco e lette dal disco come e quando necessario. `MEMORY_ONLY_SER`: consente di memorizzare come oggetti Java deserializzati. `MEMORY_AND_DISK_SER`: consente di memorizzare come oggetti Java deserializzati. Le partizioni che non corrispondono vengono memorizzate sul disco. `DISK_ONLY`: memorizza le partizioni RDD solo su disco. `MEMORY_ONLY_2, MEMORY_AND_DISK_2, etc`: simile ad altri livelli, ma ogni partizione viene replicata su due nodi cluster.

Analisi tabulazione incrociata

Calcola una tabella delle frequenze in coppia o una tabella delle contingenze in base ai valori distinti delle due colonne specificate.

Il numero di valori distinti per ogni colonna deve essere minore di 1e4.

Restituisce un dataframe che contiene la tabella di contingenza. Nella tabella delle contingenze:

Il nome della prima colonna è col1_col2, dove col1 è la prima colonna e col2 è la seconda prima della trasformazione. La prima colonna di ogni riga sono i valori distinti di col1.
Gli altri nomi di colonna sono i valori distinti di col2.
I conteggi vengono restituiti come tipo long.
Alle coppie senza ricorrenze viene assegnato zero come conteggio.
Il numero massimo di coppie diverse da zero è 1e6.
Gli elementi nulli vengono sostituiti da null.


Parametro	descrizione;
`col1`	Nome della prima colonna. Per informazioni sulle limitazioni, vedere la nota riportata di seguito. Gli elementi distinti di `col1` costituiscono il primo elemento di ogni riga nel dataframe restituito.
`col2`	Nome della seconda colonna. Per informazioni sulle limitazioni, vedere la nota riportata di seguito. Gli elementi distinti di `co2` creano i nomi delle colonne nel dataframe restituito.

Nota

Nel nome di una colonna sono consentiti solo i seguenti caratteri:

lettere minuscole e maiuscole a-z A-Z
numeri 0-9
carattere di sottolineatura _

Esempio

Si supponga che col1 sia age e che col2 sia salary.

Prima della trasformazione:

+---+------+
|age|salary|
+---+------+
|1  |100   |
|1  |200   |
|2  |100   |
|2  |100   |
|2  |300   |
|3  |200   |
|3  |300   |
+---+------+

Dopo la trasformazione:

+----------+---+---+---+
|age_salary|100|200|300|
+----------+---+---+---+
|2         |2  |0  |1  |
|1         |1  |1  |0  |
|3         |0  |1  |1  |
+----------+---+---+---+

Cubo

Genera un cubo multidimensionale di tutte le combinazioni possibili utilizzando l'elenco di colonne specificato e i calcoli nelle espressioni di funzione di aggregazione specificate.

Nelle espressioni sono supportate le seguenti funzioni di aggregazione:

AVG
COUNT
MEAN
MAX
MIN
SUM

Restituisce un dataframe dopo la trasformazione del cubo.


Parametro	descrizione;
`cubeColumns`	La lista di colonne, separate da virgole, in base alla quale generare il cubo multidimensionale.
`aggExpressions`	Espressioni della funzione di aggregazione da eseguire sulle colonne. Ad esempio: `salary -> avg, age -> max`

Esempio

Prima della trasformazione:

+----------+-----+-------+------+---+
|department|group|region |salary|age|
+----------+-----+-------+------+---+
|Eng       |A    |local  |1000  |10 |
|Art       |B    |foreign|2000  |11 |
|Sport     |C    |local  |1500  |13 |
|Eng       |A    |foreign|800   |19 |
|Art       |A    |foreign|3000  |30 |
|Eng       |E    |foreign|1000  |21 |
|Art       |D    |local  |1000  |32 |
|Sport     |C    |local  |1000  |28 |
+----------+-----+-------+------+---+

Se cubeColumns è department, region e aggExpressions è salary -> avg, age -> max (calcola lo stipendio medio e l'età massima), il cubo di trasformazione successivo sarà:

+----------+-------+-----------------+--------+
|department|region |avg(salary)      |max(age)|
+----------+-------+-----------------+--------+
|Eng       |foreign|900.0            |21      |
|Sport     |null   |1250.0           |28      |
|Art       |null   |2000.0           |32      |
|Eng       |null   |933.3333333333334|21      |
|null      |local  |1125.0           |32      |
|Art       |foreign|2500.0           |30      |
|null      |foreign|1700.0           |30      |
|Eng       |local  |1000.0           |10      |
|null      |null   |1412.5           |32      |
|Sport     |local  |1250.0           |28      |
|Art       |local  |1000.0           |32      |
+----------+-------+-----------------+--------+

Generazione di dati

Genera dati sintetici utilizzando il formato file e il contenuto specificati. Di seguito sono riportati i formati di file supportati.

CSV
JSON

Restituisce un'entità dati. L'origine dati sintetica può essere utilizzata nei test unità pipeline in cui i dati reali non vengono utilizzati o spostati.


Parametro	descrizione;
`format`	Il tipo di file. I valori supportati sono: `CSV` `JSON`
`content`	Il contenuto del file per il formato specificato.

Esempio

Esempio di contenuto CSV:

co1,co2,co3
1,B,3
A,2,C

Risultato generazione dati:

+---+---+---+
|co1|co2|co3|
+---+---+---+
|1  |B  |3  |
+---+---+---+
|A  |2  |C  |
+---+---+---+

Rimozione duplicati

Trova i duplicati nell'elenco di colonne o colonne specificato e restituisce un nuovo set di dati con le righe duplicate rimosse.


Parametro	descrizione;
`columns`	Nome di colonna o lista separata da virgole di nomi di colonna.

Esempio

Prima della trasformazione:

+---+---+
|a  |b  |
+---+---+
|1  |2  |
|3  |4  |
|1  |3  |
|2  |4  |
+---+---+

Se columns è a, il data set dopo la trasformazione è:

+---+---+
|a  |b  |
+---+---+
|1  |2  |
|3  |4  |
|2  |4  |
+---+---+

Articoli frequenti

Trova gli elementi frequenti nell'elenco di colonne o colonne specificato utilizzando la frequenza minima specificata.

L'algoritmo frequente di conteggio degli elementi proposto da Karl et al. viene utilizzato per trovare elementi frequenti. I falsi positivi sono possibili.

Restituisce un dataframe con un array di elementi frequenti per ogni colonna.


Parametro	descrizione;
`freqItems`	Nome di colonna o elenco separato da virgole di nomi di colonna per i quali si desidera trovare elementi frequenti.
`support`	Frequenza minima per un articolo da considerare frequente. Il valore deve essere maggiore di 1e-4 (valore decimale di `0.0001`). Ad esempio, `0.6` rappresenta il 60%. Cioè, un elemento che appare in almeno il 60% delle righe è un elemento frequente.

Esempio

Prima della trasformazione:

+-------+--------------+
|user_id|favorite_fruit|
+-------+--------------+
|      1|         apple|
|      2|        banana|
|      3|         apple|
|      4|        orange|
|      5|        banana|
|      6|        banana|
|      7|         apple|
+-------+--------------+

Se freqItems è favorite_fruit e support è 0.6, il dataframe restituito dopo la trasformazione è:

+------------------------+
|favorite_fruit_freqItems|
+------------------------+
|                [banana]|
+------------------------+

Na Drop

Rimuove le righe che contengono valori nulli o NaN nella colonna o nella lista di colonne specificata.

Restituisce un dataframe che esclude le righe.


Parametro	descrizione;
`how`	Come determinare se una riga deve essere eliminata. I valori supportati sono: `any`: eliminare la riga che contiene valori nulli o NaN nel valore `cols` specificato. `all`: eliminare la riga solo se ogni `cols` specificato è nullo o NaN per quella riga. Il parametro `how` viene ignorato se si specifica il parametro `minNonNulls`.
`cols`	Nome di colonna o lista separata da virgole di nomi di colonna.
`minNonNulls`	Il numero minimo di valori non nulli e non NaN che una riga può contenere. Elimina le righe che contengono meno del minimo specificato. Il parametro `minNonNulls` sostituisce il parametro `how`.

Esempio

Prima della trasformazione:

+----+-------+----+
|id  |name   |age |
+----+-------+----+
|1   |Alice  |25  |
|2   |null   |28  |
|null|Bob    |null|
|4   |Charlie|30  |
+----+-------+----+

Se how è any e cols è name, il dataframe restituito dopo la trasformazione è:

+----+-------+----+
|id  |name   |age |
+----+-------+----+
|1   |Alice  |25  |
|null|Bob    |null|
|4   |Charlie|30  |
+----+-------+----+

Quando si utilizza il parametro how con il valore all, una riga viene eliminata solo se tutti i relativi valori sono nulli. Ad esempio, prima della trasformazione:

+----+--------+----+
|  id|    name| age|
+----+--------+----+
|   1|John Doe|  30|
|   2|    null|null|
|   3|Jane Doe|  25|
|   4|Jake Doe|null|
|null|    null|null|
+----+--------+----+

Dopo la trasformazione:

+---+--------+----+
| id|    name| age|
+---+--------+----+
|  1|John Doe|  30|
|  2|    null|null|
|  3|Jane Doe|  25|
|  4|Jake Doe|null|
+---+--------+----+

Na Fill

Sostituisce i valori nulli e restituisce un dataframe utilizzando i valori sostituiti.


Parametro	descrizione;
`replacement`	La mappa chiave-valore da utilizzare per sostituire i valori nulli. La chiave è un nome di colonna. Il valore è un valore di sostituzione. La chiave indica il valore di sostituzione. Ad esempio: `name -> Tom` indica la sostituzione di valori nulli nella colonna `name` con `Tom`. Un valore di sostituzione viene convertito nel tipo di dati della colonna. Un valore sostitutivo deve essere del tipo seguente: Numero intero Long float Double Stringa Boolean

Esempio

Prima della trasformazione:

+----+-------+----+
|id  |name   |age |
+----+-------+----+
|1   |Alice  |25  |
|2   |null   |28  |
|null|Bob    |null|
|4   |Charlie|30  |
+----+-------+----+

Se la mappa chiave-valore è la seguente:

id -> 3

name -> unknown

age -> 10

Dopo la trasformazione:

+---+-------+---+
|id |name   |age|
+---+-------+---+
|1  |Alice  |25 |
|2  |unknown|28 |
|3  |Bob    |10 |
|4  |Charlie|30 |
+---+-------+---+

Na Sostituisci

Sostituisce un valore con un altro valore nella colonna o nelle colonne specificate mediante la corrispondenza delle chiavi nella chiave e nella mappa dei valori di sostituzione specificate.

Restituisce un nuovo dataframe che contiene la trasformazione sostituita.


Parametro	descrizione;
`cols`	Nome di colonna o lista separata da virgole di nomi di colonna ai quali applicare valori di sostituzione. Se `cols` è `*`, la sostituzione viene applicata a tutte le colonne stringa, numeriche o booleane.
`replacement`	La mappa chiave-valore di sostituzione da utilizzare. La chiave è un valore da sostituire. Il valore è il valore di sostituzione. Il valore della mappa può avere valori nulli. La chiave indica il valore di sostituzione. Ad esempio: `Alice -> Tom` significa sostituire `Alice` con `Tom`. La coppia chiave-valore di sostituzione deve avere lo stesso tipo. Sono supportati solo i seguenti tipi: Boolean Double Stringa

Esempio

Prima della trasformazione:

+----+-------+----+
|id  |name   |age |
+----+-------+----+
|1   |Alice  |25  |
|2   |null   |28  |
|null|Bob    |null|
|4   |Charlie|30  |
+----+-------+----+

Se cols è name e replacement è Alice -> Tom, il dataframe dopo la trasformazione è:

+----+-------+----+
|id  |name   |age |
+----+-------+----+
|1   |Tom    |25  |
|2   |null   |28  |
|null|Bob    |null|
|4   |Charlie|30  |
+----+-------+----+

Ripartizione

Divide un set di dati in base alle colonne specificate nel numero specificato di partizioni.

Restituisce un nuovo set di dati con hash partizionato. Viene restituito il numero esatto di partizione specificato.


Parametro	descrizione;
`partitionColumns`	Nome di colonna o lista separata da virgole di nomi di colonna in base alla quale il set di dati viene partizionato.
`numberOfPartitions`	Il numero di partizioni da creare.

Rollup

Genera un rollup multidimensionale di combinazioni possibili utilizzando l'elenco di colonne specificato e i calcoli nelle espressioni di funzione di aggregazione specificate.

Nelle espressioni sono supportate le seguenti funzioni di aggregazione:

AVG
COUNT
MEAN
MAX
MIN
SUM

Restituisce un dataframe dopo la trasformazione di aggregazione.


Parametro	descrizione;
`rollupColumns`	L'elenco di colonne, separate da virgole, in base al quale generare il rollup multidimensionale.
`aggExpressions`	Espressioni della funzione di aggregazione da eseguire sulle colonne. Ad esempio: `salary -> avg, age -> max`

Esempio

Prima della trasformazione:

+----------+-----+-------+------+---+
|department|group|region |salary|age|
+----------+-----+-------+------+---+
|Eng       |A    |local  |1000  |10 |
|Art       |B    |foreign|2000  |11 |
|Sport     |C    |local  |1500  |13 |
|Eng       |A    |foreign|800   |19 |
|Art       |A    |foreign|3000  |30 |
|Eng       |E    |foreign|1000  |21 |
|Art       |D    |local  |1000  |32 |
|Sport     |C    |local  |1000  |28 |
+----------+-----+-------+------+---+

Se rollupColumns è department, region e aggExpressions è salary -> avg, age -> max (calcola lo stipendio medio e l'età massima), l'aggregazione successiva alla trasformazione sarà:

+----------+-------+-----------------+--------+
|department|region |avg(salary)      |max(age)|
+----------+-------+-----------------+--------+
|Eng       |foreign|900.0            |21      |
|Sport     |null   |1250.0           |28      |
|Art       |null   |2000.0           |32      |
|Eng       |null   |933.3333333333334|21      |
|Art       |foreign|2500.0           |30      |
|Eng       |local  |1000.0           |10      |
|null      |null   |1412.5           |32      |
|Sport     |local  |1250.0           |28      |
|Art       |local  |1000.0           |32      |
+----------+-------+-----------------+--------+

Spark SQL

Esegue query Spark SQL sui dati in entrata, creando prima viste temporanee utilizzando i nomi di tabella specificati.


Parametro	descrizione;
`SQL`	Istruzione o script SQL da eseguire. Esempio: `select * from table1`
`tableName`	Nome di tabella o lista separata da virgole di nomi di tabella in base alla quale Spark crea tabelle temporanee. Esempio: `table1, table2`

Campionamento stratificato

Genera un campione stratificato senza sostituzione in base alla frazione di campionamento specificata per ogni strato.

Restituisce un nuovo dataframe che rappresenta il campione stratificato.


Parametro	descrizione;
`strata_col`	Colonna che definisce gli strati.
`fractions`	La frazione di campionamento per ogni strato, da `0.0` a `1.0`. Ad esempio, `0.1` restituisce il 10% delle righe e `1.0` restituisce il 100% delle righe. Se non viene specificata una frazione, viene assunto zero.
`sample_size`	Se non si specifica `fractions`, specificare una parte del set di dati da campionare, da `0.0` a `1.0`.
`seed`	Utilizzare qualsiasi numero casuale in `seed` per restituire lo stesso campione ogni volta, mantenendo il risultato coerente.

Esempio

Prima della trasformazione:

+---+-----+
|key|value|
+---+-----+
|  1|    1|
|  1|    2|
|  2|    1|
|  2|    1|
|  2|    3|
|  3|    2|
|  3|    3|
+---+-----+

Se strata_col è key e fractions è il seguente:

1 -> 1.0, 3 -> 0.5

Dopo la trasformazione:

+---+-----+
|key|value|
+---+-----+
|  1|    1|
|  1|    2|
|  3|    2|
+---+-----+

Riepilogo

Calcola le statistiche specificate per le colonne numeriche e di stringa.

Se non vengono fornite statistiche, vengono calcolati tutti gli elementi riportati di seguito.

COUNT
MEAN
STDDEV
MIN
quartili approssimativi (percentili al 25%, 50% e 75%)
MAX


Parametro	descrizione;
`statistics`	Elenco di statistiche separato da virgole. I valori supportati sono: `COUNT` `MEAN` `STDDEV` `MIN` uno o più percentile approssimativi arbitrari specificati come percentuale (ad esempio, `75%`) `MAX` Esempio: `count, mean, stddev, min, 27%, 41%, 95%, max`

Esempio

Prima della trasformazione:

+----------+------+-----------------+--------+
|department|gender|avg(salary)      |max(age)|
+----------+------+-----------------+--------+
|Eng       |female|900.0            |21      |
|Sport     |null  |1250.0           |28      |
|Art       |null  |2000.0           |32      |
|Eng       |null  |933.3333333333334|21      |
|Art       |female|2500.0           |30      |
|Eng       |male  |1000.0           |10      |
|null      |null  |1412.5           |32      |
|Sport     |male  |1250.0           |28      |
|Art       |male  |1000.0           |32      |
+----------+------+-----------------+--------+

Si supponga che statistics sia count, mean, stddev, min, 27%, 41%, 95%, max.

Dopo la trasformazione:

+-------+----------+-----+------+----------------+----------------+
|summary|department|group|gender|salary          |age             |
+-------+----------+-----+------+----------------+----------------+
|count  |8         |8    |8     |8               |8               |
|mean   |null      |null |null  |1412.5          |20.5            |
|stddev |null      |null |null  |749.166203188585|8.76682056718072|
|min    |Art       |A    |female|800             |10              |
|27%    |null      |null |null  |1000            |13              |
|41%    |null      |null |null  |1000            |19              |
|95%    |null      |null |null  |3000            |32              |
|max    |Sport     |E    |male  |3000            |32              |
+-------+----------+-----+------+----------------+----------------+

Documentazione dell'infrastruttura Oracle Cloud

Riferimento per gli operatori di funzione tabella

Esempio

Esempio

Esempio

Esempio

Esempio

Esempio

Esempio

Esempio

Esempio

Esempio

Esempio