IVF

Chasing Dreams

Funções de string Impala

  • todas as funções que aceitam argumentos STRING também aceitam os tipos VARCHAR e CHAR introduzidos no Impala 2.0.
  • sempre que os valores VARCHAR ou CHAR são passados para uma função que retorna um valor de string, o tipo de retorno é normalizado para STRING. Por exemplo, uma chamada para concat() com uma mistura de STRING, VARCHAR e CHAR argumentos produz um resultado STRING.

referência da função:

Impala suporta as seguintes funções de string:

  • ASCII
  • BASE64DECODE
  • BASE64ENCODE
  • BTRIM
  • CHAR_LENGTH
  • CHR
  • CONCAT
  • CONCAT_WS
  • FIND_IN_SET
  • GROUP_CONCAT
  • INITCAP
  • INSTR
  • JARO_DISTANCE, JARO_DIST
  • JARO_SIMILARITY, JARO_SIM
  • JARO_WINKER_DISTANCE, JW_DST
  • JARO_WINKER_SIMILARITY, JW_SIM
  • ESQUERDA
  • DURAÇÃO
  • LEVENSHTEIN, LE_DST
  • LOCALIZAR
  • > MENOR, LCASE
  • LPAD
  • LTRI
  • PARSE_URL
  • REGEXP_ESCAPE
  • REGEXP_EXTRACT
  • REGEXP_LIKE
  • REGEXP_REPLACE
  • REPETIR
  • SUBSTITUIR
  • INVERTER
  • DIREITO
  • RPAD
  • RTRIM
  • ESPAÇO
  • SPLIT_PART
  • STRLEFT
  • STRRIGHT
  • SUBSTR, SUBSEQÜÊNCIA de caracteres
  • TRADUZIR
  • > TRIM
  • SUPERIOR, UCASE

ASCII(STRING str) Finalidade: Retorna o código ASCII do primeiro caractere do argumento.

tipo de retorno: INT

BASE64DECODE(STRING str) Finalidade:

tipo de Retorno: STRING

observações de Uso:

funções BASE64ENCODE() e BASE64DECODE() normalmente são usados em combinação, para armazenar em um Impala tabela de dados de seqüência de caracteres que é problemático para armazenar ou transmitir. Por exemplo, você pode usar essas funções para armazenar dados de string que usam uma codificação diferente de UTF-8 ou para transformar os valores em contextos que exigem valores ASCII, como para colunas de chave de partição. Lembre-se de que os valores codificados em base64 produzem resultados diferentes para funções de string, como LENGTH(), MAX() e MIN(), do que quando essas funções são chamadas com os valores de string não codificados.

todos os valores de retorno produzidos por BASE64ENCODE() são um múltiplo de 4 bytes de comprimento. Todos os valores de argumento fornecidos a BASE64DECODE() também devem ter um múltiplo de 4 bytes de comprimento. Se um valor codificado em base64 teria um comprimento diferente, ele pode ser preenchido com caracteres = à direita para atingir um comprimento que é um múltiplo de 4 bytes.

se a string de argumento para BASE64DECODE() não representar um valor codificado em base64 válido, sujeito às restrições da implementação do Impala, como o conjunto de caracteres permitido, a função retorna NULL.

Exemplos:

BASE64ENCODE(STRING str) Finalidade:

tipo de Retorno: STRING

observações de Uso:

funções BASE64ENCODE() e BASE64DECODE() normalmente são usados em combinação, para armazenar em um Impala tabela de dados de seqüência de caracteres que é problemático para armazenar ou transmitir. Por exemplo, você pode usar essas funções para armazenar dados de string que usam uma codificação diferente de UTF-8 ou para transformar os valores em contextos que exigem valores ASCII, como para colunas de chave de partição. Lembre-se de que os valores codificados em base64 produzem resultados diferentes para funções de string, como LENGTH(), MAX() e MIN(), do que quando essas funções são chamadas com os valores de string não codificados.

todos os valores de retorno produzidos por BASE64ENCODE() são um múltiplo de 4 bytes de comprimento. Todos os valores de argumento fornecidos a BASE64DECODE() também devem ter um múltiplo de 4 bytes de comprimento. Se um valor codificado em base64 teria um comprimento diferente, ele pode ser preenchido com caracteres = à direita para atingir um comprimento que é um múltiplo de 4 bytes.

exemplos:

BTRIM(STRING a), BTRIM (STRING a, STRING chars_to_trim) propósito: remove todas as instâncias de um ou mais caracteres do início e do fim de um valorSTRING. Por padrão, remove apenas espaços. Se um segundo argumento opcional nãoNULLfor especificado, a função removerá todas as ocorrências de caracteres nesse segundo argumento do início e do final da string.

tipo de retorno: STRING

exemplos:

os exemplos a seguir mostram o comportamento padrão btrim() e o que muda quando você especifica o segundo argumento opcional. Todos os exemplos suportam o valor de saída com para que você possa ver todos os espaços principais ou finais no resultado btrim(). Por padrão, a função remove e número de espaços principais e finais. Quando o segundo argumento é especificado, qualquer número de ocorrências de qualquer caractere no segundo argumento é removido do início e do final da string de entrada; nesse caso, os espaços não são removidos (a menos que façam parte do segundo argumento) e quaisquer instâncias dos caracteres não são removidas se não vierem diretamente no início ou no final da string.

CHAR_LENGTH(STRING a), CHARACTER_LENGTH (STRING a) propósito: retorna o comprimento em caracteres da string de argumento. Aliases para a funçãolength().

tipo de retorno: INT

CHR(int character_code) finalidade: retorna um caractere especificado por um valor de ponto de código decimal. A interpretação e exibição do caractere resultante depende da localidade do sistema. Como o processamento consistente de valores de string Impala é garantido apenas para valores dentro do intervalo ASCII, use apenas essa função para valores correspondentes a caracteres ASCII. Em particular, valores de parâmetro maiores que 255 retornam uma string vazia.

tipo de retorno: STRING

notas de uso: pode ser usado como o inverso da função ascii(), que converte um caractere em seu código ASCII numérico.

exemplos:

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

CONCAT (STRING a, STRING B…) Propósito: retorna uma única string representando todos os valores do argumento Unidos.

se algum argumento for NULL, a função retornará NULL.

tipo de retorno: STRING

notas de Uso: concat() e concat_ws() são apropriados para concatenar os valores de várias colunas dentro da mesma linha, enquanto group_concat() une valores de linhas diferentes.

CONCAT_WS (string sep, STRING a, STRING B…) Propósito: retorna uma única string representando o segundo e os seguintes valores de argumento Unidos, delimitados por um separador especificado.

se algum argumento for NULL, a função retornará NULL.

tipo de retorno: STRING

notas de Uso: concat() e concat_ws() são apropriados para concatenar os valores de várias colunas dentro da mesma linha, enquanto group_concat() une valores de linhas diferentes.

FIND_IN_SET (STRING str, STRING strList) propósito: retorna a posição (a partir de 1) da primeira ocorrência de uma string especificada dentro de uma string separada por vírgulas. RetornaNULLse um dos argumentos forNULL, 0 se a string de pesquisa não for encontrada ou 0 se a string de pesquisa contiver uma vírgula.

tipo de retorno: INT

GROUP_CONCAT(STRING s ) finalidade: Retorna uma única string representando o valor do argumento concatenado em conjunto para cada linha do conjunto de resultados. Se a string separadora opcional for especificada, o separador será adicionado entre cada par de valores concatenados.

tipo de retorno: STRING

notas de Uso: concat() e concat_ws() são apropriados para concatenar os valores de várias colunas dentro da mesma linha, enquanto group_concat() une valores de linhas diferentes.

por padrão, Retorna uma única string cobrindo todo o conjunto de resultados. Para incluir outras colunas ou valores no conjunto de resultados ou para produzir várias strings concatenadas para subconjuntos de linhas, inclua uma cláusula GROUP BY na consulta.

estritamente falando, group_concat() é uma função agregada, Não uma função escalar como as outras nesta lista. Para obter detalhes e exemplos adicionais, consulte a função GROUP_CONCAT.

INITCAP(STRING str) propósito: retorna a string de entrada com a primeira letra de cada palavra em maiúsculas e todas as outras letras em minúsculas.

tipo de Retorno: STRING

Exemplo:

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

INSTR (STRING str, string substr ]) propósito: retorna a posição (a partir de 1) da primeira ocorrência de uma substring dentro de uma string mais longa.

tipo de retorno: INT

notas de Uso:

se o substr não estiver presente no str, a função retornará 0.

o terceiro e o quarto argumentos opcionais permitem encontrar instâncias do substr que não sejam a primeira instância a partir da esquerda.

JARO_DISTANCE(STRING str1, STRING str2) JARO_DST (STRING str1, STRING str2) objetivo: retorna a distância Jaro entre duas strings de entrada. A distância Jaro é uma medida de semelhança entre duas cordas e é complementar deJARO_SIMILARITY(), ou seja, (1 –JARO_SIMILARITY()).

tipo de retorno: DOUBLE

notas de Uso:

se as duas strings de entrada forem idênticas, a função retornará 0.0.

se não houver um caractere correspondente entre as strings de entrada, a função retornará 1.0.

se qualquer uma das strings de entrada for NULL, a função retornará NULL.

se o comprimento de qualquer string de entrada for maior que 255 caracteres, a função retornará um erro.

JARO_SIMILARITY(STRING str1, STRING str2) JARO_SIM (STRING str1, STRING str2) objetivo: retorna a semelhança Jaro de duas strings. Quanto maior a semelhança de Jaro para duas cordas, mais semelhantes são as cordas.

tipo de retorno: DOUBLE

notas de Uso:

se as duas strings de entrada forem idênticas, a função retornará 1.0.

se não houver um caractere correspondente entre as strings de entrada, a função retornará 0.0.

se qualquer uma das strings de entrada for NULL, a função retornará NULL.

se o comprimento de qualquer string de entrada for maior que 255 caracteres, a função retornará um erro.

JARO_WINKLER_DISTANCE(STRING str1, STRING str2) JW_DST (STRING str1, STRING str2) objetivo: retorna a distância jaro-Winkler de duas strings de entrada. É o complemento deJARO_WINKLER_SIMILARITY(), ou seja, 1 –JARO_WINKLER_SIMILARITY().

tipo de retorno: DOUBLE

notas de Uso:

se as duas strings de entrada forem idênticas, a função retornará 0.0.

se não houver um caractere correspondente entre as strings de entrada, a função retornará 1.0.

a função retorna um erro nos seguintes casos:

  • o comprimento de qualquer string de entrada é maior que 255 caracteres.
  • scaling_factor < 0.0 ou scaling_factor > 0.25
  • boost_threshold < 0.0 ou boost_threshold > 1.0

Se seqüências de caracteres de entrada é NULL, a função retorna NULL.

o Fator de escala padrão é 0.1.

o peso do prefixo só será aplicado se a distância Jaro exceder o boost_threshold opcional. Por padrão, o valor boost_threshold é 0.7.

JARO_WINKLER_SIMILARITY(STRING str1, STRING str2) JARO_SIM (STRING str1, STRING str2) objetivo: retorna a semelhança Jaro-Winkler entre duas strings de entrada. A semelhança Jaro-Winkler usa um peso de prefixo, especificado pelo fator de escala, que dá classificações mais favoráveis às strings que correspondem desde o início a um comprimento de prefixo definido, até um máximo de quatro caracteres.

Use as funções Jaro ou jaro-Winkler para executar correspondências difusas em strings relativamente curtas, por exemplo, para limpar entradas de nomes de usuários em relação aos registros no banco de dados.

tipo de retorno: DOUBLE

notas de Uso:

se as duas strings de entrada forem idênticas, a função retornará 1.0.

se não houver um caractere correspondente entre as strings de entrada, a função retornará 0.0.

a função retorna um erro nos seguintes casos:

  • o comprimento de qualquer string de entrada é maior que 255 caracteres.
  • scaling_factor < 0.0 ou scaling_factor > 0.25
  • boost_threshold < 0.0 ou boost_threshold > 1.0

Se seqüências de caracteres de entrada é NULL, a função retorna NULL.

o Fator de escala padrão é 0.1.

o peso do prefixo só será aplicado se o jaro-similarity exceder o boost_threshold opcional. Por padrão, o valor boost_threshold é 0.7.

esquerda (STRING A, INT num_chars) veja a funçãoSTRLEFT(). LENGTH (STRING A) propósito: retorna o comprimento em caracteres da string de argumento.

tipo de retorno: INT

LEVENSHTEIN(STRING str1, STRING str2), LE_DST (STRING str1, STRING str2) objetivo: retorna a distância Levenshtein entre duas strings de entrada. A distância de Levenshtein entre duas strings é o número mínimo de edições de caractere único necessárias para transformar uma string para outra. A função indica quão diferentes são as strings de entrada.

tipo de retorno: INT

notas de Uso:

se as strings de entrada forem iguais, a função retornará 0.

se qualquer uma das entradas exceder 255 caracteres, a função retornará um erro.

se qualquer uma das cadeias de entrada for NULL, a função retornará NULL.

se o comprimento de uma string de entrada for zero, a função retornará o comprimento da outra string.

exemplo:

LEVENSHTEIN ('welcome', 'We come') retorna 2, primeiro mude para substituir ‘w‘ para ‘W‘ e, em seguida, para substituir ‘l‘ para um caractere de espaço.

localizar (string substr, STRING str) propósito: retorna a posição (a partir de 1) da primeira ocorrência de uma substring dentro de uma string mais longa, opcionalmente após uma posição específica.

Return type: INT

LOWER (STRING a), LCASE(STRING a) Purpose: retorna a string de argumento convertida em letras minúsculas.

tipo de retorno: STRING

notas de Uso:

em Impala 2.5 e superior, você pode simplificar consultas que usam muitas chamadas UPPER() e LOWER() para fazer comparações sem distinção entre maiúsculas e minúsculas, usando os operadores ILIKE ou IREGEXP.

LPAD (STRING str, INT len, STRING pad) propósito: retorna uma string de um comprimento especificado, com base na primeira string de argumento. Se a string especificada for muito curta, ela será preenchida à esquerda com uma sequência repetida dos caracteres da string pad. Se a string especificada for muito longa, ela será truncada à direita.

tipo de retorno: STRING

LTRIM(STRING a ) finalidade: Retorna a string de argumento com todas as ocorrências de caracteres especificados pelo segundo argumento removido do lado esquerdo. Remove espaços se o segundo argumento não for especificado.

tipo de retorno: STRING

PARSE_URL (STRING urlString, STRING partToExtract ) objetivo: retorna a parte de um URL correspondente a uma parte especificada. O argumento da parte pode ser'PROTOCOL','HOST','PATH','REF','AUTHORITY','FILE','USERINFO', ou'QUERY'. Maiúsculas são necessárias para esses valores literais. Ao solicitar a parteQUERYdo URL, você pode especificar opcionalmente uma chave para recuperar apenas o valor associado dos pares chave-valor na string de consulta.

tipo de retorno: STRING

notas de Uso: Esta função é importante para o caso de uso tradicional do Hadoop de interpretar logs da web. Por exemplo, se os dados de tráfego da web apresentarem URLs brutos não divididos em colunas de tabela separadas, você poderá contar os visitantes para uma página específica extraindo o campo 'PATH' ou 'FILE' ou analisando os Termos de pesquisa extraindo a chave correspondente do campo 'QUERY'.

REGEXP_ESCAPE (STRING source) propósito: a funçãoREGEXP_ESCAPEretorna uma string escapada para o caractere especial na biblioteca RE2 para que os caracteres especiais sejam interpretados literalmente em vez de como caracteres especiais. Os seguintes caracteres especiais são escapados pela função:

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

tipo de retorno: string

no Impala 2.0 e posterior, a sintaxe de expressão regular do Impala está em conformidade com a sintaxe de expressão Regular estendida POSIX usada pela biblioteca google RE2. Para obter detalhes, consulte a documentação do RE2. Tem a maioria dos idiomas familiares de expressões regulares em Perl, Python e assim por diante, incluindo .*? para correspondências não gananciosas.

no Impala 2.0 e posterior, uma mudança na biblioteca de Expressões Regulares subjacente pode causar mudanças na maneira como as expressões regulares são interpretadas por esta função. Teste todas as consultas que usam expressões regulares e ajuste os padrões de expressão, se necessário.

como o interpretador impala-shell usa o caractere \ para escapar, use \ para representar o caractere de escape da expressão regular em qualquer expressão regular que você enviar por meio do impala-shell . Você pode preferir usar os nomes de classe de caracteres equivalentes, como ] em vez de \d que você teria que escapar como \d.

exemplos:

este exemplo mostra escapar de um dos caracteres especiais em RE2.

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

este exemplo mostra escapar de todos os caracteres especiais em 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 (STRING subject, STRING pattern, INT index) objetivo: retorna o grupo especificado () de uma string com base em um padrão de expressão regular. O grupo 0 refere-se a toda a string extraída, enquanto o grupo 1, 2 e assim por diante refere-se à primeira, segunda e assim por diante(...)porção.

tipo de retorno: STRING

no Impala 2.0 e posterior, a sintaxe de expressão regular do Impala está em conformidade com a sintaxe de expressão Regular estendida POSIX usada pela biblioteca google RE2. Para obter detalhes, consulte a documentação do RE2. Tem a maioria dos idiomas familiares de expressões regulares em Perl, Python e assim por diante, incluindo .*? para correspondências não gananciosas.

no Impala 2.0 e posterior, uma mudança na biblioteca de Expressões Regulares subjacente pode causar mudanças na maneira como as expressões regulares são interpretadas por esta função. Teste todas as consultas que usam expressões regulares e ajuste os padrões de expressão, se necessário.

como o interpretador impala-shell usa o caractere \ para escapar, use \ para representar o caractere de escape da expressão regular em qualquer expressão regular que você enviar por meio do impala-shell . Você pode preferir usar os nomes de classe de caracteres equivalentes, como ] em vez de \d que você teria que escapar como \d.

exemplos:

este exemplo mostra como o grupo 0 corresponde à string de padrão completo, incluindo a parte fora de qualquer grupo () :

este exemplo mostra como o grupo 1 corresponde apenas ao conteúdo dentro do primeiro grupo () na string de padrão:

ao contrário das versões anteriores do Impala, a biblioteca de expressão regular usada no Impala 2.0 e posterior suporta o idioma .*? para correspondências não gananciosas. Este exemplo mostra como uma string de padrão começando com .*? corresponde à parte mais curta possível da string de origem, retornando o conjunto mais à direita de letras minúsculas. Uma string de padrão começando e terminando com .*? encontra duas correspondências potenciais de igual comprimento e retorna a primeira encontrada (o conjunto mais à esquerda de letras minúsculas).

REGEXP_LIKE (STRING source, STRING pattern) propósito: retornatrueoufalsepara indicar se a string de origem contém em qualquer lugar dentro dela a expressão regular dada pelo padrão. O terceiro argumento opcional consiste em sinalizadores de letras que mudam a forma como a correspondência é executada, comoipara correspondência que não diferencia maiúsculas de minúsculas.

sintaxe:

os sinalizadores que você pode incluir no terceiro argumento opcional são:

  • c: correspondência sensível a maiúsculas e minúsculas (o padrão).
  • i: correspondência caso-insensível. Se várias instâncias de c e i forem incluídas no terceiro argumento, a última opção terá precedência.
  • m: correspondência multi-linha. Os operadores ^ e $ correspondem ao início ou ao fim de qualquer linha dentro da string de origem, não ao início e ao fim de toda a string.
  • n: correspondência de nova linha. O operador . pode corresponder ao caractere de nova linha. Um operador de repetição como .* pode corresponder a uma parte da string de origem que abrange várias linhas.

tipo de retorno: BOOLEAN

no Impala 2.0 e posterior, a sintaxe de expressão regular do Impala está em conformidade com a sintaxe de expressão Regular estendida POSIX usada pela biblioteca google RE2. Para obter detalhes, consulte a documentação do RE2. Tem a maioria dos idiomas familiares de expressões regulares em Perl, Python e assim por diante, incluindo .*? para correspondências não gananciosas.

Em Impala 2.0 e posterior, uma alteração na biblioteca de Expressões Regulares subjacente pode causar alterações na forma como as expressões regulares são interpretadas por esta função. Teste todas as consultas que usam expressões regulares e ajuste os padrões de expressão, se necessário.

como o interpretador impala-shell usa o caractere \ para escapar, use \ para representar o caractere de escape da expressão regular em qualquer expressão regular que você enviar por meio do impala-shell . Você pode preferir usar os nomes de classe de caracteres equivalentes, como ] em vez de \d que você teria que escapar como \d.

Exemplos:

Este exemplo mostra como REGEXP_LIKE() pode testar a existência de vários tipos de expressão regular padrões dentro de uma cadeia de caracteres fonte:

REGEXP_REPLACE(SEQÜÊNCIA inicial, padrão de SEQÜÊNCIA de caracteres, de SEQÜÊNCIA de caracteres de substituição) Finalidade: Retorna o argumento inicial com o padrão de expressão regular substituído pelo final argumento de seqüência de caracteres.

tipo de retorno: STRING

em Impala 2.0 e posterior, a sintaxe de expressão regular Impala está em conformidade com a sintaxe de expressão Regular estendida POSIX usada pela biblioteca google RE2. Para obter detalhes, consulte a documentação do RE2. Tem a maioria dos idiomas familiares de expressões regulares em Perl, Python e assim por diante, incluindo .*? para correspondências não gananciosas.

no Impala 2.0 e posterior, uma mudança na biblioteca de Expressões Regulares subjacente pode causar mudanças na maneira como as expressões regulares são interpretadas por esta função. Teste todas as consultas que usam expressões regulares e ajuste os padrões de expressão, se necessário.

como o interpretador impala-shell usa o caractere \ para escapar, use \ para representar o caractere de escape da expressão regular em qualquer expressão regular que você enviar por meio do impala-shell . Você pode preferir usar os nomes de classe de caracteres equivalentes, como ] em vez de \d que você teria que escapar como \d.

exemplos:

esses exemplos mostram como você pode substituir partes de uma string combinando um padrão com texto de substituição, que podem incluir backreferências a qualquer () grupos na string de padrão. Os números de backreference começam em 1 e quaisquer caracteres \ devem ser escapados como \.

Substituir um padrão de caracteres com o novo texto:

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

Substituir um padrão de caracteres com substituição de texto que inclui o original de correspondência de texto:

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

Remover todos os caracteres que não são dígitos:

REPITA(STRING str, INT n) Finalidade: Retorna o argumento de seqüência de caracteres repetidos um número especificado de vezes.

tipo de retorno: STRING

substituir (STRING inicial, STRING alvo, STRING substituição) finalidade: Retorna o argumento inicial com todas as ocorrências da string de destino substituídas pela string de substituição.

tipo de retorno: STRING

notas de Uso:

como esta função não usa nenhum padrão de expressão regular, normalmente é mais rápido do que REGEXP_REPLACE() para substituições de string simples.

se algum argumento for NULL, o valor de retorno será NULL.

a correspondência diferencia maiúsculas de minúsculas.

se a string de substituição contiver outra instância da string de destino, a expansão será executada apenas uma vez, em vez de aplicar novamente à string recém-construída.

exemplos:

propósito reverso (STRING a): Retorna a string de argumento com caracteres na ordem inversa.

tipo de retorno: STRING

direita (STRING A, INT num_chars) veja a funçãoSTRRIGHT. RPAD (STRING str, INT len, STRING pad) propósito: retorna uma string de um comprimento especificado, com base na primeira string de argumento. Se a string especificada for muito curta, ela será preenchida à direita com uma sequência repetida dos caracteres da string pad. Se a string especificada for muito longa, ela será truncada à direita.

tipo de retorno: STRING

RTRIM (STRING A ) propósito: retorna a string de argumento com todas as ocorrências de caracteres especificados pelo segundo argumento removido do lado direito. Remove espaços se o segundo argumento não for especificado.

tipo de retorno: STRING

espaço(INT n) finalidade: retorna uma string concatenada do número especificado de espaços. Abreviação pararepeat(' ',n).

tipo de retorno: STRING

SPLIT_PART (fonte de STRING, delimitador de STRING, índice BIGINT) objetivo: retorna aindexTH parte solicitada da string de origem de entrada dividida pelo delimitador.

  • se o índice for um número positivo, retorna a parte indexth da esquerda dentro da string de origem.
  • se o índice for um número negativo, retorna a parte indexth da direita dentro da string de origem.
  • se o índice for 0, retorna um erro.

o delimitador pode consistir em vários caracteres, não apenas um único caractere.

toda correspondência do delimitador é feita exatamente, não usando nenhum padrão de expressão regular.

tipo de Retorno: STRING

Exemplos:

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

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

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

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

STRLEFT(STRING A, INT num_chars) propósito: retorna os caracteres mais à esquerda da string. Abreviação para uma chamada parasubstr()com 2 argumentos.

tipo de retorno: STRING

STRRIGHT (STRING A, INT num_chars) finalidade: retorna os caracteres mais à direita da string. Abreviação para uma chamada parasubstr()com 2 argumentos.

tipo de Retorno: STRING

SUBSTR(STRING a, INT start ), SUBSTRING(STRING a, INT start ) Finalidade: Retorna a parte da string iniciando em um ponto especificado, opcionalmente, com um comprimento máximo especificado. Os caracteres na string são indexados a partir de 1.

Return type: STRING

TRANSLATE(STRING input, STRING from, STRING to) Purpose: retorna a stringinputcom cada caractere no argumentofromsubstituído pelo caractere correspondente no argumentoto. Os caracteres são correspondidos na ordem em que aparecem emfrometo.

por exemplo: translate ('hello world','world','earth') retorna 'hetta earth'.

tipo de Retorno: STRING

observações de Uso:

Se from contém mais caracteres do que to, o from caracteres que estão além do comprimento de to são removidos no resultado.

Por exemplo:

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

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

se from for NULL, a função retorna NULL.

se to contiver mais caracteres do que from, os caracteres extras em to serão ignorados.

se from contiver caracteres duplicados, o caractere duplicado será substituído pelo primeiro caractere correspondente em to.

por exemplo: translate ('hello','ll','67') retorna 'he66o'.

TRIM(STRING a) Purpose: retorna a string de entrada com os espaços à esquerda e à direita removidos. O mesmo que passar a string porLTRIM()eRTRIM(). Notas de Utilização: frequentemente utilizado durante operações de limpeza de dados durante o ciclo ETL, se os valores de entrada ainda puderem ter espaços circundantes. Para uma função de uso mais geral que pode remover outros caracteres principais e finais além dos espaços, consulteBTRIM().

tipo de retorno: STRING

UPPER(STRING a), UCASE(STRING a) propósito: retorna a string de argumento convertida em maiúsculas.

tipo de Retorno: STRING

observações de Uso:

No Impala 2.5 e posterior, você pode simplificar as consultas que utilizam muitos UPPER() e LOWER() chamadas para fazer insensível a maiúsculas e minúsculas comparações, usando o ILIKE ou IREGEXP operadores.

Deixe uma resposta

O seu endereço de email não será publicado.