IVF

Chasing Dreams

Funzioni stringa Impala

  • Tutte le funzioni che accettano argomenti STRING accettano anche i tipi VARCHAR e CHAR introdotti in Impala 2.0.
  • Ogni volta che i valori VARCHAR o CHAR vengono passati a una funzione che restituisce un valore stringa, il tipo restituito viene normalizzato a STRING. Ad esempio, una chiamata a concat() con un mix di argomenti STRING, VARCHAR e CHAR produce un risultato STRING.

Funzione di riferimento:

Impala supporta le seguenti funzioni di stringa:

  • ASCII
  • BASE64DECODE
  • BASE64ENCODE
  • BTRIM
  • CHAR_LENGTH
  • CHR
  • CONCAT
  • CONCAT_WS
  • FIND_IN_SET
  • GROUP_CONCAT
  • MAIUSCOLA
  • STRUMENTI
  • JARO_DISTANCE, JARO_DIST
  • JARO_SIMILARITY, JARO_SIM
  • JARO_WINKER_DISTANCE, JW_DST
  • JARO_WINKER_SIMILARITY, JW_SIM
  • SINISTRA
  • LUNGHEZZA
  • DI LEVENSHTEIN, LE_DST
  • TROVARE
  • > INFERIORE, LCASE
  • LPAD
  • LTRI
  • PARSE_URL
  • REGEXP_ESCAPE
  • REGEXP_EXTRACT
  • REGEXP_LIKE
  • REGEXP_REPLACE
  • RIPETERE
  • SOSTITUIRE
  • REVERSE
  • DIRITTO
  • RPAD
  • RTRIM
  • SPAZIO
  • SPLIT_PART
  • STRLEFT
  • STRRIGHT
  • SUBSTR, SUBSTRING
  • TRANSLATE
  • TAGLIARE
  • SUPERIORE, UCASE

ASCII(STRING str) Funzione: Restituisce numerico codice ASCII del primo carattere dell’argomento.

Tipo di ritorno: INT

BASE64DECODE(STRING str) Scopo:

Tipo di ritorno: STRING

Note di utilizzo:

Le funzioni BASE64ENCODE() e BASE64DECODE() vengono in genere utilizzate in combinazione, per memorizzare in una stringa di tabella Impala dati problematici da memorizzare o trasmettere. Ad esempio, è possibile utilizzare queste funzioni per memorizzare dati stringa che utilizzano una codifica diversa da UTF-8 o per trasformare i valori in contesti che richiedono valori ASCII, ad esempio per le colonne delle chiavi di partizione. Tieni presente che i valori codificati con base64 producono risultati diversi per le funzioni di stringa come LENGTH(), MAX() e MIN() rispetto a quando tali funzioni vengono chiamate con i valori di stringa non codificati.

Tutti i valori di ritorno prodotti da BASE64ENCODE() sono un multiplo di 4 byte di lunghezza. Tutti i valori degli argomenti forniti a BASE64DECODE() devono anche essere un multiplo di 4 byte di lunghezza. Se un valore codificato base64 avrebbe altrimenti una lunghezza diversa, può essere riempito con caratteri finali = per raggiungere una lunghezza che è un multiplo di 4 byte.

Se la stringa di argomenti di BASE64DECODE()non rappresenta un valore codificato base64 valido, soggetto ai vincoli dell’implementazione Impala come il set di caratteri consentiti, la funzione restituisce NULL.

Esempi:

BASE64ENCODE (STRING str) Scopo:

Tipo di ritorno: STRING

Note di utilizzo:

Le funzioni BASE64ENCODE() e BASE64DECODE() vengono in genere utilizzate in combinazione, per memorizzare in una stringa di tabella Impala dati problematici da memorizzare o trasmettere. Ad esempio, è possibile utilizzare queste funzioni per memorizzare dati stringa che utilizzano una codifica diversa da UTF-8 o per trasformare i valori in contesti che richiedono valori ASCII, ad esempio per le colonne delle chiavi di partizione. Tieni presente che i valori codificati con base64 producono risultati diversi per le funzioni di stringa come LENGTH(), MAX() e MIN() rispetto a quando tali funzioni vengono chiamate con i valori di stringa non codificati.

Tutti i valori di ritorno prodotti da BASE64ENCODE() sono un multiplo di 4 byte di lunghezza. Tutti i valori degli argomenti forniti a BASE64DECODE() devono anche essere un multiplo di 4 byte di lunghezza. Se un valore codificato base64 avrebbe altrimenti una lunghezza diversa, può essere riempito con caratteri finali = per raggiungere una lunghezza che è un multiplo di 4 byte.

Esempi:

BTRIM(STRINGA a), BTRIM (STRINGA a, STRINGA chars_to_trim) Scopo: Rimuove tutte le istanze di uno o più caratteri dall’inizio e dalla fine di un valoreSTRING. Per impostazione predefinita, rimuove solo gli spazi. Se viene specificato un secondo argomento opzionale nonNULL, la funzione rimuove tutte le occorrenze di caratteri in quel secondo argomento dall’inizio e dalla fine della stringa.

Tipo di ritorno: STRING

Esempi:

I seguenti esempi mostrano il comportamento predefinito btrim() e cosa cambia quando si specifica il secondo argomento opzionale. Tutti gli esempi racchiudono il valore di output con in modo da poter vedere qualsiasi spazio iniziale o finale nel risultato btrim(). Per impostazione predefinita, la funzione rimuove e numero di spazi iniziali e finali. Quando viene specificato il secondo argomento, qualsiasi numero di occorrenze di qualsiasi carattere nel secondo argomento viene rimosso dall’inizio e dalla fine della stringa di input; in questo caso, gli spazi non vengono rimossi (a meno che non facciano parte del secondo argomento) e tutte le istanze dei caratteri non vengono rimosse se non arrivano all’inizio o alla fine della stringa.

CHAR_LENGTH(STRING a), CHARACTER_LENGTH (STRING a) Scopo: Restituisce la lunghezza in caratteri della stringa argomento. Alias per la funzionelength().

Tipo di ritorno: INT

CHR (INT character_code) Scopo: Restituisce un carattere specificato da un valore di punto di codice decimale. L’interpretazione e la visualizzazione del carattere risultante dipendono dalle impostazioni locali del sistema. Poiché l’elaborazione coerente dei valori stringa Impala è garantita solo per i valori all’interno dell’intervallo ASCII, utilizzare questa funzione solo per i valori corrispondenti ai caratteri ASCII. In particolare, i valori dei parametri maggiori di 255 restituiscono una stringa vuota.

Tipo di ritorno: STRING

Note di utilizzo: Può essere utilizzato come inverso della funzione ascii(), che converte un carattere nel suo codice ASCII numerico.

Esempi:

SELECT chr(65);+---------+| chr(65) |+---------+| A |+---------+SELECT chr(97);+---------+| chr(97) |+---------+| a |+---------+

CONCAT (STRINGA a, STRINGA b…) Scopo: Restituisce una singola stringa che rappresenta tutti i valori degli argomenti uniti.

Se un argomento è NULL, la funzione restituisce NULL.

Tipo di ritorno: STRING

Note di utilizzo: concat() e concat_ws() sono appropriati per concatenare i valori di più colonne all’interno della stessa riga, mentre group_concat() unisce i valori di righe diverse.

CONCAT_WS (STRINGA sep, STRINGA a, STRINGA b…) Scopo: Restituisce una singola stringa che rappresenta il secondo e i seguenti valori di argomento uniti tra loro, delimitati da un separatore specificato.

Se un argomento è NULL, la funzione restituisce NULL.

Tipo di ritorno: STRING

Note di utilizzo: concat() e concat_ws() sono appropriati per concatenare i valori di più colonne all’interno della stessa riga, mentre group_concat() unisce i valori di righe diverse.

FIND_IN_SET(STRING str, STRING strList) Scopo: Restituisce la posizione (a partire da 1) della prima occorrenza di una stringa specificata all’interno di una stringa separata da virgole. RestituisceNULLse uno dei due argomenti èNULL, 0 se la stringa di ricerca non viene trovata o 0 se la stringa di ricerca contiene una virgola.

Tipo di ritorno: INT

GROUP_CONCAT(STRING s ) Scopo: Restituisce una singola stringa che rappresenta il valore dell’argomento concatenato insieme per ogni riga del set di risultati. Se viene specificata la stringa separatore opzionale, il separatore viene aggiunto tra ogni coppia di valori concatenati.

Tipo di ritorno: STRING

Note di utilizzo: concat() e concat_ws() sono appropriati per concatenare i valori di più colonne all’interno della stessa riga, mentre group_concat() unisce i valori di righe diverse.

Per impostazione predefinita, restituisce una singola stringa che copre l’intero set di risultati. Per includere altre colonne o valori nel set di risultati o per produrre più stringhe concatenate per sottoinsiemi di righe, includere una clausola GROUP BY nella query.

In senso stretto, group_concat() è una funzione aggregata, non una funzione scalare come le altre in questa lista. Per ulteriori dettagli ed esempi, vedere la funzione GROUP_CONCAT.

INITCAP(STRING str) Scopo: Restituisce la stringa di input con la prima lettera di ogni parola in maiuscolo e tutte le altre lettere in minuscolo.

Tipo di ritorno: STRING

Esempio:

INITCAP("i gOt mY ChiCkeNs in tHe yard.") restituisce "I Got My Chickens In The Yard.".

INSTR (STRING str, STRING substr ]) Scopo: Restituisce la posizione (a partire da 1) della prima occorrenza di una sottostringa all’interno di una stringa più lunga.

Tipo di ritorno: INT

Note di utilizzo:

Se il substr non è presente in str, la funzione restituisce 0.

Il terzo e il quarto argomento opzionali consentono di trovare istanze del substr diverse dalla prima istanza a partire da sinistra.

JARO_DISTANCE(STRING str1, STRING str2) JARO_DST (STRING str1, STRING str2) Scopo: Restituisce la distanza Jaro tra due stringhe di input. La distanza di Jaro è una misura di somiglianza tra due stringhe ed è il complementare diJARO_SIMILARITY(), cioè (1 –JARO_SIMILARITY()).

Tipo di ritorno: DOUBLE

Note di utilizzo:

Se le due stringhe di input sono identiche, la funzione restituisce 0.0.

Se non ci sono caratteri corrispondenti tra le stringhe di input, la funzione restituisce 1.0.

Se una delle stringhe di input è NULL, la funzione restituisce NULL.

Se la lunghezza di una stringa di input è maggiore di 255 caratteri, la funzione restituisce un errore.

JARO_SIMILARITY(STRING str1, STRING str2) JARO_SIM (STRING str1, STRING str2) Scopo: Restituisce la somiglianza Jaro di due stringhe. Maggiore è la somiglianza di Jaro per due corde, più le corde sono simili.

Tipo di ritorno: DOUBLE

Note di utilizzo:

Se le due stringhe di input sono identiche, la funzione restituisce 1.0.

Se non ci sono caratteri corrispondenti tra le stringhe di input, la funzione restituisce 0.0.

Se una delle stringhe di input è NULL, la funzione restituisce NULL.

Se la lunghezza di una stringa di input è maggiore di 255 caratteri, la funzione restituisce un errore.

JARO_WINKLER_DISTANCE(STRING str1, STRING str2) JW_DST (STRING str1, STRING str2) Scopo: Restituisce la distanza Jaro-Winkler di due stringhe di input. È il complementare diJARO_WINKLER_SIMILARITY(), cioè 1 –JARO_WINKLER_SIMILARITY().

Tipo di ritorno: DOUBLE

Note di utilizzo:

Se le due stringhe di input sono identiche, la funzione restituisce 0.0.

Se non ci sono caratteri corrispondenti tra le stringhe di input, la funzione restituisce 1.0.

La funzione restituisce un errore nei seguenti casi:

  • La lunghezza di una stringa di input è maggiore di 255 caratteri.
  • scaling_factor < 0.0 o scaling_factor > 0.25
  • boost_threshold < 0.0 o boost_threshold > 1.0

Se le stringhe di input è NULL, la funzione restituisce NULL.

Il fattore di scala predefinito è 0.1.

Il peso del prefisso verrà applicato solo se la distanza Jaro supera la boost_threshold opzionale. Per impostazione predefinita, il valore boost_threshold è 0.7.

JARO_WINKLER_SIMILARITY(STRING str1, STRING str2) JARO_SIM (STRING str1, STRING str2) Scopo: Restituisce la somiglianza Jaro-Winkler tra due stringhe di input. La somiglianza Jaro-Winkler utilizza un peso prefisso, specificato dal fattore di scala, che fornisce valutazioni più favorevoli alle stringhe che corrispondono dall’inizio per una lunghezza del prefisso impostata, fino a un massimo di quattro caratteri.

Utilizzare le funzioni Jaro o Jaro-Winkler per eseguire corrispondenze fuzzy su stringhe relativamente brevi, ad esempio per strofinare gli input dell’utente dei nomi rispetto ai record nel database.

Tipo di ritorno: DOUBLE

Note di utilizzo:

Se le due stringhe di input sono identiche, la funzione restituisce 1.0.

Se non ci sono caratteri corrispondenti tra le stringhe di input, la funzione restituisce 0.0.

La funzione restituisce un errore nei seguenti casi:

  • La lunghezza di una stringa di input è maggiore di 255 caratteri.
  • scaling_factor < 0.0 o scaling_factor > 0.25
  • boost_threshold < 0.0 o boost_threshold > 1.0

Se le stringhe di input è NULL, la funzione restituisce NULL.

Il fattore di scala predefinito è 0.1.

Il peso del prefisso verrà applicato solo se la somiglianza Jaro supera l’opzione boost_threshold. Per impostazione predefinita, il valore boost_threshold è 0.7.

SINISTRA (STRINGA a, INT num_chars) Vedere la funzioneSTRLEFT(). LUNGHEZZA (STRINGA a) Scopo: Restituisce la lunghezza in caratteri della stringa argomento.

Tipo di ritorno: INT

LEVENSHTEIN(STRING str1, STRING str2), LE_DST (STRING str1, STRING str2) Scopo: Restituisce la distanza di Levenshtein tra due stringhe di input. La distanza di Levenshtein tra due stringhe è il numero minimo di modifiche a carattere singolo necessarie per trasformare una stringa in un’altra. La funzione indica quanto sono diverse le stringhe di input.

Tipo di ritorno: INT

Note di utilizzo:

Se le stringhe di input sono uguali, la funzione restituisce 0.

Se uno degli input supera i 255 caratteri, la funzione restituisce un errore.

Se una stringa di input è NULL, la funzione restituisce NULL.

Se la lunghezza di una stringa di input è zero, la funzione restituisce la lunghezza dell’altra stringa.

Esempio:

LEVENSHTEIN ('welcome', 'We come') restituisce 2, prima modifica per sostituire ‘w‘ in ‘W‘ e quindi per sostituire ‘l‘ in un carattere di spazio.

LOCATE (STRING substr, STRING str) Scopo: Restituisce la posizione (a partire da 1) della prima occorrenza di una sottostringa all’interno di una stringa più lunga, facoltativamente dopo una particolare posizione.

Tipo di ritorno: INT

LOWER(STRING a), LCASE (STRING a) Scopo: Restituisce la stringa di argomenti convertita in tutte le lettere minuscole.

Tipo di ritorno: STRING

Note di utilizzo:

In Impala 2.5 e versioni successive, è possibile semplificare le query che utilizzano molte chiamate UPPER() e LOWER() per eseguire confronti senza distinzione tra maiuscole e minuscole, utilizzando invece gli operatori ILIKE o IREGEXP.

LPAD(STRING str, INT len, STRING pad) Scopo: Restituisce una stringa di una lunghezza specificata, basata sulla prima stringa di argomento. Se la stringa specificata è troppo breve, viene riempita a sinistra con una sequenza ripetuta dei caratteri della stringa del pad. Se la stringa specificata è troppo lunga, viene troncata a destra.

Tipo di ritorno: STRING

LTRIM(STRINGA a ) Scopo: Restituisce la stringa argomento con tutte le occorrenze di caratteri specificati dal secondo argomento rimosso dal lato sinistro. Rimuove gli spazi se il secondo argomento non è specificato.

Tipo di ritorno: STRING

PARSE_URL(STRING urlString, STRING partToExtract ) Scopo: Restituisce la porzione di un URL corrispondente a una parte specificata. L’argomento parte può essere'PROTOCOL','HOST','PATH','REF','AUTHORITY','FILE','USERINFO', oppure'QUERY'. Per questi valori letterali è necessario il maiuscolo. Quando si richiede la porzioneQUERYdell’URL, è possibile specificare facoltativamente una chiave per recuperare solo il valore associato dalle coppie chiave-valore nella stringa di query.

Tipo di ritorno: STRING

Note di utilizzo: Questa funzione è importante per il tradizionale caso d’uso Hadoop di interpretare i log web. Ad esempio, se i dati sul traffico Web presentano URL non elaborati non suddivisi in colonne di tabella separate, è possibile contare i visitatori di una determinata pagina estraendo il campo 'PATH' o 'FILE' o analizzare i termini di ricerca estraendo la chiave corrispondente dal campo 'QUERY'.

REGEXP_ESCAPE(STRING source) Scopo: La funzioneREGEXP_ESCAPErestituisce una stringa con escape per il carattere speciale nella libreria RE2 in modo che i caratteri speciali vengano interpretati letteralmente anziché come caratteri speciali. I seguenti caratteri speciali sono sfuggiti dalla funzione:

.\+*?$(){}=!<>|:-

Tipo di ritorno: string

In Impala 2.0 e versioni successive, la sintassi delle espressioni regolari Impala è conforme alla sintassi delle espressioni regolari estese POSIX utilizzata dalla libreria RE2 di Google. Per i dettagli, vedere la documentazione RE2. Ha la maggior parte degli idiomi familiari dalle espressioni regolari in Perl, Python e così via, incluso .*? per le partite non avide.

In Impala 2.0 e versioni successive, una modifica nella libreria di espressioni regolari sottostante potrebbe causare cambiamenti nel modo in cui le espressioni regolari vengono interpretate da questa funzione. Testare tutte le query che utilizzano espressioni regolari e regolare i modelli di espressione, se necessario.

Poiché l’interprete impala-shell utilizza il carattere \ per l’escape, utilizzare \ per rappresentare il carattere di escape dell’espressione regolare in qualsiasi espressione regolare inviata tramite impala-shell . Potresti preferire usare i nomi di classe di caratteri equivalenti, come ] invece di \dche dovresti escape come \d.

Esempi:

Questo esempio mostra l’escape di uno dei caratteri speciali in RE2.

+------------------------------------------------------+| regexp_escape('Hello.world') |+------------------------------------------------------+| Hello\.world |+------------------------------------------------------+

Questo esempio mostra l’escape di tutti i caratteri speciali in RE2.

+------------------------------------------------------------+| regexp_escape('a.b\c+d*e?fh$i(j)k{l}m=n!o<p>q|r:s-t') |+------------------------------------------------------------+| a\.b\c\+d\*e\?f\h$i\(j\)k\{l\}m\=n\!o\<p\>q\|r\:s\-t |+------------------------------------------------------------+

REGEXP_EXTRACT (oggetto STRINGA, motivo STRINGA, indice INT) Scopo: Restituisce il gruppo specificato () da una stringa basata su un modello di espressione regolare. Il gruppo 0 si riferisce all’intera stringa estratta, mentre il gruppo 1, 2 e così via si riferisce alla prima, alla seconda e così via(...)porzione.

Tipo di ritorno: STRING

In Impala 2.0 e versioni successive, la sintassi delle espressioni regolari Impala è conforme alla sintassi delle espressioni regolari estese POSIX utilizzata dalla libreria RE2 di Google. Per i dettagli, vedere la documentazione RE2. Ha la maggior parte degli idiomi familiari dalle espressioni regolari in Perl, Python e così via, incluso .*? per le partite non avide.

In Impala 2.0 e versioni successive, una modifica nella libreria di espressioni regolari sottostante potrebbe causare cambiamenti nel modo in cui le espressioni regolari vengono interpretate da questa funzione. Testare tutte le query che utilizzano espressioni regolari e regolare i modelli di espressione, se necessario.

Poiché l’interprete impala-shell utilizza il carattere \ per l’escape, utilizzare \ per rappresentare il carattere di escape dell’espressione regolare in qualsiasi espressione regolare inviata tramite impala-shell . Potresti preferire usare i nomi di classe di caratteri equivalenti, come ] invece di \dche dovresti escape come \d.

Esempi:

Questo esempio mostra come il gruppo 0 corrisponde alla stringa di pattern completa, inclusa la porzione esterna a qualsiasi gruppo () :

Questo esempio mostra come il gruppo 1 corrisponda solo al contenuto del primo gruppo () nella stringa di pattern:

A differenza delle versioni precedenti di Impala, la libreria di espressioni regolari utilizzata in Impala 2.0 e versioni successive supporta l’idioma .*? per le corrispondenze non avide. Questo esempio mostra come una stringa di pattern che inizia con .*? corrisponda alla porzione più breve possibile della stringa di origine, restituendo il set più a destra di lettere minuscole. Una stringa di pattern che inizia e termina con .*? trova due possibili corrispondenze di uguale lunghezza e restituisce la prima trovata (l’insieme più a sinistra di lettere minuscole).

REGEXP_LIKE(STRING source, STRING pattern) Scopo: Restituiscetrueofalseper indicare se la stringa di origine contiene in qualsiasi punto al suo interno l’espressione regolare data dal pattern. Il terzo argomento opzionale è costituito da flag di lettere che cambiano il modo in cui viene eseguita la corrispondenza, ad esempioiper la corrispondenza senza distinzione tra maiuscole e minuscole.

Sintassi:

I flag che è possibile includere nel terzo argomento opzionale sono:

  • c: Corrispondenza sensibile al maiuscolo / minuscolo (impostazione predefinita).
  • i: Corrispondenza senza distinzione tra maiuscole e minuscole. Se più istanze di c e i sono incluse nel terzo argomento, l’ultima opzione di questo tipo ha la precedenza.
  • m: Corrispondenza multi-linea. Gli operatori ^ e $ corrispondono all’inizio o alla fine di qualsiasi riga all’interno della stringa di origine, non all’inizio e alla fine dell’intera stringa.
  • n: Corrispondenza nuova riga. L’operatore . può corrispondere al carattere di nuova riga. Un operatore di ripetizione come .* può corrispondere a una porzione della stringa di origine che si estende su più righe.

Tipo di ritorno: BOOLEAN

In Impala 2.0 e versioni successive, la sintassi delle espressioni regolari Impala è conforme alla sintassi delle espressioni regolari estese POSIX utilizzata dalla libreria RE2 di Google. Per i dettagli, vedere la documentazione RE2. Ha la maggior parte degli idiomi familiari dalle espressioni regolari in Perl, Python e così via, incluso .*? per le partite non avide.

In Impala 2.0 e versioni successive, una modifica nella libreria di espressioni regolari sottostante potrebbe causare modifiche nel modo in cui le espressioni regolari vengono interpretate da questa funzione. Testare tutte le query che utilizzano espressioni regolari e regolare i modelli di espressione, se necessario.

Poiché l’interprete impala-shell utilizza il carattere \ per l’escape, utilizzare \ per rappresentare il carattere di escape dell’espressione regolare in qualsiasi espressione regolare inviata tramite impala-shell . Potresti preferire usare i nomi di classe di caratteri equivalenti, come ] invece di \dche dovresti escape come \d.

Esempi:

Questo esempio mostra come REGEXP_LIKE() può verificare l’esistenza di vari tipi di pattern di espressioni regolari all’interno di una stringa di origine:

REGEXP_REPLACE(STRING initial, STRING pattern, STRING replacement) Scopo: Restituisce l’argomento iniziale con il pattern di espressioni regolari sostituito dalla stringa di argomenti finale.

Tipo di ritorno: STRING

In Impala 2.0 e versioni successive, la sintassi delle espressioni regolari Impala è conforme alla sintassi delle espressioni regolari estese POSIX utilizzata dalla libreria RE2 di Google. Per i dettagli, vedere la documentazione RE2. Ha la maggior parte degli idiomi familiari dalle espressioni regolari in Perl, Python e così via, incluso .*? per le partite non avide.

In Impala 2.0 e versioni successive, una modifica nella libreria di espressioni regolari sottostante potrebbe causare cambiamenti nel modo in cui le espressioni regolari vengono interpretate da questa funzione. Testare tutte le query che utilizzano espressioni regolari e regolare i modelli di espressione, se necessario.

Poiché l’interprete impala-shell utilizza il carattere \ per l’escape, utilizzare \ per rappresentare il carattere di escape dell’espressione regolare in qualsiasi espressione regolare inviata tramite impala-shell . Potresti preferire usare i nomi di classe di caratteri equivalenti, come ] invece di \dche dovresti escape come \d.

Esempi:

Questi esempi mostrano come è possibile sostituire parti di una stringa che corrispondono a un pattern con testo sostitutivo, che può includere backreferences a qualsiasi gruppo () nella stringa pattern. I numeri backreference iniziano da 1 e qualsiasi carattere \ deve essere escape come \.

Sostituire un modello di carattere con un nuovo testo:

 > select regexp_replace('aaabbbaaa','b+','xyz');+------------------------------------------+| regexp_replace('aaabbbaaa', 'b+', 'xyz') |+------------------------------------------+| aaaxyzaaa |+------------------------------------------+Returned 1 row(s) in 0.11s

Sostituire un modello di carattere con testo di sostituzione che include il testo corrispondente originale:

 > select regexp_replace('aaabbbaaa','(b+)','<\1>');+----------------------------------------------+| regexp_replace('aaabbbaaa', '(b+)', '<\1>') |+----------------------------------------------+| aaa<bbb>aaa |+----------------------------------------------+Returned 1 row(s) in 0.11s

Rimuovi tutti i caratteri che non sono cifre:

REPEAT (STRING str, INT n) Scopo: Restituisce la stringa dell’argomento ripetuta un numero specificato di volte.

Tipo di ritorno: STRING

SOSTITUIRE (STRINGA iniziale, destinazione STRINGA, sostituzione STRINGA) Scopo: Restituisce l’argomento iniziale con tutte le occorrenze della stringa di destinazione sostituita dalla stringa di sostituzione.

Tipo di ritorno: STRING

Note di utilizzo:

Poiché questa funzione non utilizza alcun modello di espressione regolare, in genere è più veloce di REGEXP_REPLACE() per le sostituzioni di stringhe semplici.

Se un argomento è NULL, il valore restituito è NULL.

La corrispondenza è sensibile al maiuscolo / minuscolo.

Se la stringa di sostituzione contiene un’altra istanza della stringa di destinazione, l’espansione viene eseguita solo una volta, invece di applicarla nuovamente alla stringa appena costruita.

Esempi:

REVERSE(STRING a) Scopo: Restituisce la stringa argomento con caratteri in ordine inverso.

Tipo di ritorno: STRING

DESTRA(STRINGA a, INT num_chars) Vedere la funzioneSTRRIGHT. RPAD (STRING str, INT len, STRING pad) Scopo: Restituisce una stringa di una lunghezza specificata, basata sulla prima stringa di argomento. Se la stringa specificata è troppo breve, viene riempita a destra con una sequenza ripetuta dei caratteri della stringa del pad. Se la stringa specificata è troppo lunga, viene troncata a destra.

Tipo di ritorno: STRING

RTRIM(STRING a ) Scopo: Restituisce la stringa argomento con tutte le occorrenze di caratteri specificati dal secondo argomento rimosso dal lato destro. Rimuove gli spazi se il secondo argomento non è specificato.

Tipo di ritorno: STRING

SPAZIO (INT n) Scopo: Restituisce una stringa concatenata del numero specificato di spazi. Abbreviazione direpeat(' ',n).

Tipo di ritorno: STRING

SPLIT_PART (STRING source, STRING delimiter, BIGINT index) Scopo: Restituisce la richiestaindexesima parte della stringa sorgente di input divisa dal delimitatore.

  • Se index è un numero positivo, restituisce la parte indexth da sinistra all’interno della stringa di origine.
  • Se index è un numero negativo, restituisce la parte indexth da destra all’interno della stringa di origine.
  • Se l’indice è 0, restituisce un errore.

Il delimitatore può essere composto da più caratteri, non solo da un singolo carattere.

Tutta la corrispondenza del delimitatore viene eseguita esattamente, senza utilizzare alcun modello di espressione regolare.

Tipo di ritorno: STRING

Esempi:

SPLIT_PART('x,y,z',',',2) restituisce 'y'.

SPLIT_PART('one***two***three','***',2) restituisce 'two'.

SPLIT_PART('[email protected]@[email protected]@ghi', '@@', 3) restituisce 'ghi'.

SPLIT_PART('[email protected]@[email protected]@ghi', '@@', -3) restituisce 'abc'.

STRLEFT (STRING a, INT num_chars) Scopo: Restituisce i caratteri più a sinistra della stringa. Abbreviazione per una chiamata asubstr()con 2 argomenti.

Tipo di ritorno: STRING

STRRIGHT (STRING a, INT num_chars) Scopo: Restituisce i caratteri più a destra della stringa. Abbreviazione per una chiamata asubstr()con 2 argomenti.

Tipo di ritorno: STRING

SUBSTR(STRING a, INT start ), SUBSTRING(STRING a, INT start ) Scopo: Restituisce la porzione della stringa che inizia in un punto specificato, facoltativamente con una lunghezza massima specificata. I caratteri nella stringa sono indicizzati a partire da 1.

Tipo di ritorno: STRING

TRANSLATE(STRING input, STRING from, STRING to) Scopo: Restituisce la stringainputcon ogni carattere nell’argomentofromsostituito con il carattere corrispondente nell’argomentoto. I caratteri sono abbinati nell’ordine in cui appaiono infrometo.

Ad esempio: translate ('hello world','world','earth')restituisce 'hetta earth'.

Tipo di ritorno: STRING

Note di utilizzo:

Se from contiene più caratteri di to, i caratteri from che superano la lunghezza di to vengono rimossi nel risultato.

Per esempio:

translate('abcdedg', 'bcd', '1') restituisce 'a1eg'.

translate('Unit Number#2', '# ', '_') restituisce 'UnitNumber_2'.

Se from è NULL, la funzione restituisce NULL.

Se to contiene più caratteri di from , i caratteri aggiuntivi in to vengono ignorati.

Se from contiene caratteri duplicati, il carattere duplicato viene sostituito con il primo carattere corrispondente in to.

Ad esempio: translate ('hello','ll','67')restituisce 'he66o'.

TRIM(STRING a) Scopo: Restituisce la stringa di input con entrambi gli spazi iniziali e finali rimossi. Lo stesso che passare la stringa attraverso entrambiLTRIM()eRTRIM().

Note di utilizzo: spesso utilizzato durante le operazioni di pulizia dei dati durante il ciclo ETL, se i valori di input potrebbero avere ancora spazi circostanti. Per una funzione più generale che può rimuovere altri caratteri iniziali e finali oltre agli spazi, vedere BTRIM().

Tipo di ritorno: STRING

UPPER(STRING a), UCASE(STRING a) Scopo: Restituisce la stringa di argomenti convertita in maiuscole.

Tipo di ritorno: STRING

Note di utilizzo:

In Impala 2.5 e versioni successive, è possibile semplificare le query che utilizzano molte chiamate UPPER() e LOWER() per eseguire confronti senza distinzione tra maiuscole e minuscole, utilizzando invece gli operatori ILIKE o IREGEXP.

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.