Apache Presto - Guia rápido

A análise de dados é o processo de análise de dados brutos para reunir informações relevantes para uma melhor tomada de decisão. É usado principalmente em muitas organizações para tomar decisões de negócios. Bem, a análise de big data envolve uma grande quantidade de dados e esse processo é bastante complexo, portanto, as empresas usam estratégias diferentes.

Por exemplo, o Facebook é uma das maiores empresas de armazenamento de dados orientadas a dados do mundo. Os dados de warehouse do Facebook são armazenados no Hadoop para computação em grande escala. Mais tarde, quando os dados do warehouse cresceram para petabytes, eles decidiram desenvolver um novo sistema com baixa latência. No ano de 2012, os membros da equipe do Facebook criaram“Presto” para análise de consulta interativa que operaria rapidamente mesmo com petabytes de dados.

O que é Apache Presto?

Apache Presto é um mecanismo de execução de consulta paralela distribuído, otimizado para baixa latência e análise de consulta interativa. Presto executa consultas facilmente e escala sem tempo de inatividade, mesmo de gigabytes a petabytes.

Uma única consulta Presto pode processar dados de várias fontes, como HDFS, MySQL, Cassandra, Hive e muitas outras fontes de dados. Presto é construído em Java e fácil de integrar com outros componentes de infraestrutura de dados. Presto é poderoso, e empresas líderes como Airbnb, DropBox, Groupon, Netflix o estão adotando.

Presto - Recursos

Presto contém os seguintes recursos -

  • Arquitetura simples e extensível.
  • Conectores plugáveis ​​- Presto oferece suporte a conectores plugáveis ​​para fornecer metadados e dados para consultas.
  • Execuções pipelined - evita sobrecarga de latência de E / S desnecessária.
  • Funções definidas pelo usuário - os analistas podem criar funções personalizadas definidas pelo usuário para migrar facilmente.
  • Processamento colunar vetorizado.

Presto - Benefícios

Aqui está uma lista de benefícios que o Apache Presto oferece -

  • Operações SQL especializadas
  • Fácil de instalar e depurar
  • Abstração de armazenamento simples
  • Escala dados de petabytes rapidamente com baixa latência

Presto - Aplicativos

O Presto oferece suporte à maioria das melhores aplicações industriais da atualidade. Vamos dar uma olhada em alguns dos aplicativos notáveis.

  • Facebook- Facebook construiu Presto para necessidades de análise de dados. O Presto dimensiona facilmente grandes velocidades de dados.

  • Teradata- A Teradata fornece soluções ponta a ponta em análise de Big Data e armazenamento de dados. A contribuição da Teradata para o Presto torna mais fácil para mais empresas atender a todas as necessidades analíticas.

  • Airbnb- O Presto é parte integrante da infraestrutura de dados do Airbnb. Bem, centenas de funcionários estão executando consultas todos os dias com a tecnologia.

Por que Presto?

O Presto suporta ANSI SQL padrão, o que o torna muito fácil para analistas de dados e desenvolvedores. Embora seja construído em Java, ele evita problemas típicos de código Java relacionados à alocação de memória e coleta de lixo. O Presto tem uma arquitetura de conector compatível com Hadoop. Ele permite conectar facilmente sistemas de arquivos.

O Presto é executado em várias distribuições do Hadoop. Além disso, o Presto pode acessar a partir de uma plataforma Hadoop para consultar o Cassandra, bancos de dados relacionais ou outros armazenamentos de dados. Esse recurso analítico de plataforma cruzada permite que os usuários do Presto extraiam o máximo valor comercial de gigabytes a petabytes de dados.

A arquitetura do Presto é quase semelhante à arquitetura DBMS MPP (processamento massivamente paralelo) clássica. O diagrama a seguir ilustra a arquitetura do Presto.

O diagrama acima consiste em diferentes componentes. A tabela a seguir descreve cada um dos componentes em detalhes.

S.No Descrição do componente
1

Client

O cliente (Presto CLI) envia instruções SQL a um coordenador para obter o resultado.

2

Coordinator

O coordenador é um daemon mestre. O coordenador inicialmente analisa as consultas SQL e, em seguida, analisa e planeja a execução da consulta. O Scheduler executa a execução do pipeline, atribui o trabalho ao nó mais próximo e monitora o progresso.

3 -

Connector

Os plug-ins de armazenamento são chamados de conectores. Hive, HBase, MySQL, Cassandra e muitos outros atuam como um conector; caso contrário, você também pode implementar um personalizado. O conector fornece metadados e dados para consultas. O coordenador usa o conector para obter metadados para construir um plano de consulta.

4 -

Worker

O coordenador atribui tarefas aos nós de trabalho. Os trabalhadores obtêm dados reais do conector. Finalmente, o nó do trabalhador entrega o resultado ao cliente.

Presto - Fluxo de Trabalho

Presto é um sistema distribuído que funciona em um cluster de nós. O mecanismo de consulta distribuído do Presto é otimizado para análise interativa e oferece suporte a ANSI SQL padrão, incluindo consultas complexas, agregações, junções e funções de janela. A arquitetura do Presto é simples e extensível. O cliente Presto (CLI) envia instruções SQL para um coordenador mestre daemon.

O planejador se conecta por meio do pipeline de execução. O planejador atribui trabalho aos nós que estão mais próximos dos dados e monitora o progresso. O coordenador atribui tarefas a vários nós de trabalho e, finalmente, o nó de trabalho entrega o resultado de volta ao cliente. O cliente extrai dados do processo de saída. A extensibilidade é o design chave. Conectores plugáveis ​​como Hive, HBase, MySQL, etc., fornecem metadados e dados para consultas. O Presto foi projetado com uma “abstração de armazenamento simples” que torna fácil fornecer capacidade de consulta SQL contra esses diferentes tipos de fontes de dados.

Modelo de Execução

Presto oferece suporte a consulta personalizada e mecanismo de execução com operadores projetados para oferecer suporte à semântica SQL. Além da programação aprimorada, todo o processamento fica na memória e é canalizado pela rede entre os diferentes estágios. Isso evita sobrecarga de latência de E / S desnecessária.

Este capítulo explicará como instalar o Presto em sua máquina. Vamos examinar os requisitos básicos do Presto,

  • Linux ou Mac OS
  • Java versão 8

Agora, vamos continuar as etapas a seguir para instalar o Presto em sua máquina.

Verificando a instalação do Java

Felizmente, você já instalou o Java versão 8 em sua máquina agora, então apenas verifique-o usando o seguinte comando.

$ java -version

Se o Java for instalado com sucesso em sua máquina, você poderá ver a versão do Java instalado. Se o Java não estiver instalado, siga as etapas subsequentes para instalar o Java 8 em sua máquina.

Baixe o JDK. Baixe a versão mais recente do JDK visitando o link a seguir.

http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html

A versão mais recente é JDK 8u 92 e o arquivo é “jdk-8u92-linux-x64.tar.gz”. Faça download do arquivo em sua máquina.

Depois disso, extraia os arquivos e vá para o diretório específico.

Em seguida, defina alternativas Java. Finalmente, o Java será instalado em sua máquina.

Instalação do Apache Presto

Baixe a versão mais recente do Presto visitando o seguinte link,

https://repo1.maven.org/maven2/com/facebook/presto/presto-server/0.149/

Agora, a última versão de “presto-server-0.149.tar.gz” será baixada em sua máquina.

Extrair arquivos tar

Extraia o tar arquivo usando o seguinte comando -

$ tar  -zxf  presto-server-0.149.tar.gz 
$ cd presto-server-0.149

Definições de configuração

Crie um diretório de “dados”

Crie um diretório de dados fora do diretório de instalação, que será usado para armazenar logs, metadados, etc., para que seja facilmente preservado ao atualizar o Presto. É definido usando o seguinte código -

$ cd  
$ mkdir data

Para visualizar o caminho onde está localizado, use o comando “pwd”. Este local será designado no próximo arquivo node.properties.

Crie o diretório “etc”

Crie um diretório etc dentro do diretório de instalação do Presto usando o seguinte código -

$ cd presto-server-0.149 
$ mkdir etc

Este diretório manterá os arquivos de configuração. Vamos criar cada arquivo um por um.

Propriedades do nó

O arquivo de propriedades do nó Presto contém a configuração ambiental específica para cada nó. Ele é criado dentro do diretório etc (etc / node.properties) usando o seguinte código -

$ cd etc 
$ vi node.properties  

node.environment = production 
node.id = ffffffff-ffff-ffff-ffff-ffffffffffff 
node.data-dir = /Users/../workspace/Presto

Depois de fazer todas as alterações, salve o arquivo e saia do terminal. Aquinode.data é o caminho do local do diretório de dados criado acima. node.id representa o identificador exclusivo de cada nó.

Configuração JVM

Crie um arquivo “jvm.config” dentro do diretório etc (etc / jvm.config). Este arquivo contém uma lista de opções de linha de comando usadas para iniciar a Java Virtual Machine.

$ cd etc 
$ vi jvm.config  

-server 
-Xmx16G 
-XX:+UseG1GC 
-XX:G1HeapRegionSize = 32M 
-XX:+UseGCOverheadLimit 
-XX:+ExplicitGCInvokesConcurrent 
-XX:+HeapDumpOnOutOfMemoryError 
-XX:OnOutOfMemoryError = kill -9 %p

Depois de fazer todas as alterações, salve o arquivo e saia do terminal.

Propriedades de configuração

Crie um arquivo “config.properties” dentro do diretório etc (etc / config.properties). Este arquivo contém a configuração do servidor Presto. Se você estiver configurando uma única máquina para teste, o servidor Presto pode funcionar apenas como o processo de coordenação, conforme definido usando o código a seguir -

$ cd etc 
$ vi config.properties  

coordinator = true 
node-scheduler.include-coordinator = true 
http-server.http.port = 8080 
query.max-memory = 5GB 
query.max-memory-per-node = 1GB 
discovery-server.enabled = true 
discovery.uri = http://localhost:8080

Aqui,

  • coordinator - nó mestre.

  • node-scheduler.include-coordinator - Permite agendamento de trabalho no coordenador.

  • http-server.http.port - Especifica a porta para o servidor HTTP.

  • query.max-memory=5GB - A quantidade máxima de memória distribuída.

  • query.max-memory-per-node=1GB - A quantidade máxima de memória por nó.

  • discovery-server.enabled - O Presto usa o serviço Discovery para encontrar todos os nós do cluster.

  • discovery.uri - o URI para o servidor Discovery.

Se você estiver configurando um servidor Presto de várias máquinas, o Presto funcionará como um processo de coordenação e de trabalho. Use esta definição de configuração para testar o servidor Presto em várias máquinas.

Configuração para Coordenador

$ cd etc 
$ vi config.properties  

coordinator = true 
node-scheduler.include-coordinator = false 
http-server.http.port = 8080 
query.max-memory = 50GB 
query.max-memory-per-node = 1GB 
discovery-server.enabled = true 
discovery.uri = http://localhost:8080

Configuração para trabalhador

$ cd etc 
$ vi config.properties  

coordinator = false 
http-server.http.port = 8080 
query.max-memory = 50GB 
query.max-memory-per-node = 1GB 
discovery.uri = http://localhost:8080

Propriedades de log

Crie um arquivo “log.properties” dentro do diretório etc (etc / log.properties). Este arquivo contém o nível mínimo de log para hierarquias de logger nomeadas. É definido usando o seguinte código -

$ cd etc 
$ vi log.properties  
com.facebook.presto = INFO

Salve o arquivo e saia do terminal. Aqui, quatro níveis de log são usados, como DEBUG, INFO, WARN e ERROR. O nível de registro padrão é INFO.

Propriedades do Catálogo

Crie um diretório “catálogo” dentro do diretório etc (etc / catalog). Isso será usado para montar dados. Por exemplo, crieetc/catalog/jmx.properties com o seguinte conteúdo para montar o jmx connector como o catálogo jmx -

$ cd etc 
$ mkdir catalog $ cd catalog 
$ vi jmx.properties  
connector.name = jmx

Iniciar Presto

O Presto pode ser iniciado usando o seguinte comando,

$ bin/launcher start

Então você verá uma resposta semelhante a esta,

Started as 840

Execute o Presto

Para iniciar o servidor Presto, use o seguinte comando -

$ bin/launcher run

Depois de iniciar o servidor Presto com sucesso, você pode encontrar os arquivos de log no diretório “var / log”.

  • launcher.log - Este log é criado pelo ativador e conectado aos fluxos stdout e stderr do servidor.

  • server.log - Este é o principal arquivo de log usado pelo Presto.

  • http-request.log - Solicitação HTTP recebida pelo servidor.

A partir de agora, você instalou com êxito as definições de configuração do Presto em sua máquina. Vamos continuar as etapas para instalar o Presto CLI.

Instale o Presto CLI

O Presto CLI fornece um shell interativo baseado em terminal para a execução de consultas.

Baixe o Presto CLI visitando o seguinte link,

https://repo1.maven.org/maven2/com/facebook/presto/presto-cli/0.149/

Agora, “presto-cli-0.149-executable.jar” será instalado em sua máquina.

Executar CLI

Depois de baixar o presto-cli, copie-o para o local de onde deseja executá-lo. Este local pode ser qualquer nó que tenha acesso à rede para o coordenador. Primeiro altere o nome do arquivo Jar para Presto. Em seguida, torne-o executável comchmod + x comando usando o seguinte código -

$ mv presto-cli-0.149-executable.jar presto  
$ chmod +x presto

Agora execute a CLI usando o seguinte comando,

./presto --server localhost:8080 --catalog jmx --schema default  
Here jmx(Java Management Extension) refers to catalog and default referes to schema.

Você verá a seguinte resposta,

presto:default>

Agora digite o comando “jps” em seu terminal e você verá os daemons em execução.

Pare Presto

Depois de ter realizado todas as execuções, você pode parar o servidor presto usando o seguinte comando -

$ bin/launcher stop

Este capítulo irá discutir as configurações do Presto.

Verificador Presto

O Presto Verifier pode ser usado para testar o Presto em relação a outro banco de dados (como MySQL) ou para testar dois clusters Presto entre si.

Criar banco de dados em MySQL

Abra o servidor MySQL e crie um banco de dados usando o seguinte comando.

create database test

Agora você criou o banco de dados de “teste” no servidor. Crie a tabela e carregue-a com a seguinte consulta.

CREATE TABLE verifier_queries( 
   id INT NOT NULL AUTO_INCREMENT, 
   suite VARCHAR(256) NOT NULL, 
   name VARCHAR(256), 
   test_catalog VARCHAR(256) NOT NULL, 
   test_schema VARCHAR(256) NOT NULL, 
   test_prequeries TEXT, 
   test_query TEXT NOT NULL, 
   test_postqueries TEXT, 
   test_username VARCHAR(256) NOT NULL default 'verifier-test', 
   test_password VARCHAR(256), 
   control_catalog VARCHAR(256) NOT NULL, 
   control_schema VARCHAR(256) NOT NULL, 
   control_prequeries TEXT, 
   control_query TEXT NOT NULL, 
   control_postqueries TEXT, 
   control_username VARCHAR(256) NOT NULL default 'verifier-test', 
   control_password VARCHAR(256), 
   session_properties_json TEXT,            
   PRIMARY KEY (id) 
);

Adicionar configurações de configuração

Crie um arquivo de propriedades para configurar o verificador -

$ vi config.properties  

suite = mysuite 
query-database = jdbc:mysql://localhost:3306/tutorials?user=root&password=pwd 
control.gateway = jdbc:presto://localhost:8080 
test.gateway = jdbc:presto://localhost:8080 
thread-count = 1

Aqui no query-database campo, digite os seguintes detalhes - nome do banco de dados mysql, nome de usuário e senha.

Baixar arquivo JAR

Baixe o arquivo jar do Presto-verifier visitando o seguinte link,

https://repo1.maven.org/maven2/com/facebook/presto/presto-verifier/0.149/

Agora a versão “presto-verifier-0.149-executable.jar” é baixado em sua máquina.

Executar JAR

Execute o arquivo JAR usando o seguinte comando,

$ mv presto-verifier-0.149-executable.jar verifier  
$ chmod+x verifier

Executar verificador

Execute o verificador usando o seguinte comando,

$ ./verifier config.properties

Criar a tabela

Vamos criar uma tabela simples em “test” banco de dados usando a seguinte consulta.

create table product(id int not null, name varchar(50))

Insira a tabela

Depois de criar uma tabela, insira dois registros usando a seguinte consulta,

insert into product values(1,’Phone') 
insert into product values(2,’Television’)

Executar consulta do verificador

Execute a seguinte consulta de amostra no terminal do verificador (./verifier config.propeties) para verificar o resultado do verificador.

Consulta de amostra

insert into verifier_queries (suite, test_catalog, test_schema, test_query, 
control_catalog, control_schema, control_query) values 
('mysuite', 'mysql', 'default', 'select * from mysql.test.product', 
'mysql', 'default', 'select * from mysql.test.product');

Aqui, select * from mysql.test.product consulta refere-se ao catálogo mysql, test é o nome do banco de dados e producté o nome da tabela. Desta forma, você pode acessar o conector mysql usando o servidor Presto.

Aqui, duas mesmas consultas selecionadas são testadas entre si para ver o desempenho. Da mesma forma, você pode executar outras consultas para testar os resultados de desempenho. Você também pode conectar dois clusters Presto para verificar os resultados de desempenho.

Neste capítulo, discutiremos as ferramentas de administração usadas no Presto. Vamos começar com a interface da Web do Presto.

Interface web

O Presto oferece uma interface web para monitorar e gerenciar consultas. Ele pode ser acessado a partir do número da porta especificado nas Propriedades de configuração do coordenador.

Inicie o servidor Presto e o Presto CLI. Em seguida, você pode acessar a interface da web a partir do seguinte url -http://localhost:8080/

A saída será semelhante à tela acima.

Aqui, a página principal tem uma lista de consultas junto com informações como ID exclusivo da consulta, texto da consulta, estado da consulta, porcentagem concluída, nome de usuário e fonte de origem da consulta. As consultas mais recentes são executadas primeiro e, em seguida, as consultas concluídas ou não concluídas são exibidas na parte inferior.

Ajustando o desempenho no Presto

Se o cluster Presto estiver tendo problemas relacionados ao desempenho, altere suas configurações padrão para as configurações a seguir.

Propriedades de configuração

  • task. info -refresh-max-wait - Reduz a carga de trabalho do coordenador.

  • task.max-worker-threads - Divide o processo e atribui a cada nó de trabalho.

  • distributed-joins-enabled - Junções distribuídas baseadas em hash.

  • node-scheduler.network-topology - Define a topologia da rede para o planejador.

Configurações JVM

Altere suas configurações JVM padrão para as configurações a seguir. Isso será útil para diagnosticar problemas de coleta de lixo.

-XX:+PrintGCApplicationConcurrentTime 
-XX:+PrintGCApplicationStoppedTime 
-XX:+PrintGCCause 
-XX:+PrintGCDateStamps 
-XX:+PrintGCTimeStamps 
-XX:+PrintGCDetails 
-XX:+PrintReferenceGC 
-XX:+PrintClassHistogramAfterFullGC 
-XX:+PrintClassHistogramBeforeFullGC 
-XX:PrintFLSStatistics = 2 
-XX:+PrintAdaptiveSizePolicy 
-XX:+PrintSafepointStatistics 
-XX:PrintSafepointStatisticsCount = 1

Neste capítulo, discutiremos como criar e executar consultas no Presto. Vamos examinar os tipos de dados básicos suportados pelo Presto.

Tipos de dados básicos

A tabela a seguir descreve os tipos de dados básicos do Presto.

S.No Tipo de dados e descrição
1

VARCHAR

Dados de caracteres de comprimento variável

2

BIGINT

Um inteiro assinado de 64 bits

3 -

DOUBLE

Um valor de dupla precisão de ponto flutuante de 64 bits

4 -

DECIMAL

Um número decimal de precisão fixa. Por exemplo DECIMAL (10,3) - 10 é a precisão, ou seja, o número total de dígitos e 3 é o valor da escala representado como um ponto fracionário. A escala é opcional e o valor padrão é 0

5

BOOLEAN

Valores booleanos verdadeiros e falsos

6

VARBINARY

Dados binários de comprimento variável

7

JSON

Dados JSON

8

DATE

Tipo de dados de data representado como ano-mês-dia

9

TIME, TIMESTAMP, TIMESTAMP with TIME ZONE

TIME - hora do dia (hora-min-seg-milissegundo)

TIMESTAMP - Data e hora do dia

TIMESTAMP com TIME ZONE - Data e hora do dia com fuso horário do valor

10

INTERVAL

Amplie ou amplie os tipos de dados de data e hora

11

ARRAY

Matriz do tipo de componente fornecido. Por exemplo, ARRAY [5,7]

12

MAP

Mapeie entre os tipos de componentes fornecidos. Por exemplo, MAP (ARRAY ['um', 'dois'], ARRAY [5,7])

13

ROW

Estrutura de linha composta de campos nomeados

Presto - Operadores

Os operadores Presto estão listados na tabela a seguir.

S.No Operador e descrição
1 Operador aritmético

Presto suporta operadores aritméticos como +, -, *, /,%

2 Operador relacional

<,>, <=,> =, =, <>

3 - Operador lógico

AND, OR, NOT

4 - Operador de alcance

O operador de intervalo é usado para testar o valor em um intervalo específico. Presto suporta BETWEEN, IS NULL, IS NOT NULL, GREATEST e MENOS

5 Operador decimal

O operador decimal aritmético binário executa a operação aritmética binária para o tipo decimal Operador decimal unário - O - operator realiza negação

6 Operador string

o ‘||’ operator realiza concatenação de strings

7 Operador de data e hora

Executa operações aritméticas de adição e subtração em tipos de dados de data e hora

8 Operador de matriz

Operador subscrito [] - acessa um elemento de uma matriz

Operador de concatenação || - concatenar uma matriz com uma matriz ou um elemento do mesmo tipo

9 Operador de mapa

Operador de subscrito do mapa [] - recupera o valor correspondente a uma determinada chave de um mapa

No momento, estávamos discutindo a execução de algumas consultas básicas simples no Presto. Este capítulo discutirá as funções SQL importantes.

Funções Matemáticas

As funções matemáticas operam em fórmulas matemáticas. A tabela a seguir descreve a lista de funções em detalhes.

S.No. Descrição da função
1 abs (x)

Retorna o valor absoluto de x

2 cbrt (x)

Retorna a raiz cúbica de x

3 - teto (x)

Retorna o x valor arredondado para o número inteiro mais próximo

4 -

ceil(x)

Alias ​​para teto (x)

5 graus (x)

Retorna o valor do grau para x

6 ex)

Devolve o valor duplo do número de Euler

7

exp(x)

Retorna o valor expoente do número de Euler

8 andar (x)

Devoluções x arredondado para baixo para o número inteiro mais próximo

9

from_base(string,radix)

Retorna o valor da string interpretado como um número base-raiz

10

ln(x)

Retorna o logaritmo natural de x

11 log2 (x)

Retorna o logaritmo de base 2 de x

12

log10(x)

Retorna o logaritmo de base 10 de x

13

log(x,y)

Retorna a base y logaritmo de x

14 mod (n, m)

Retorna o módulo (resto) de n dividido por m

15

pi()

Retorna o valor de pi. O resultado será devolvido como um valor duplo

16 potência (x, p)

Retorna poder de valor ‘p’ ao x valor

17

pow(x,p)

Alias ​​para potência (x, p)

18 radianos (x)

converte o ângulo x em graus radianos

19

rand()

Alias ​​para radianos ()

20 aleatória()

Retorna o valor pseudo-aleatório

21

rand(n)

Alias ​​para aleatório ()

22 rodada (x)

Retorna o valor arredondado para x

23

round(x,d)

x valor arredondado para o ‘d’ casas decimais

24

sign(x)

Retorna a função signum de x, ou seja,

0 se o argumento for 0

1 se o argumento for maior que 0

-1 se o argumento for menor que 0

Para argumentos duplos, a função retorna adicionalmente -

NaN se o argumento for NaN

1 se o argumento for + Infinito

-1 se o argumento for -Infinity

25 sqrt (x)

Retorna a raiz quadrada de x

26 to_base (x, raiz)

O tipo de retorno é arqueiro. O resultado é retornado como a raiz de base parax

27 truncar (x)

Trunca o valor de x

28 largura_bucket (x, limite1, limite2, n)

Retorna o número do compartimento de x limites de limite1 e limite2 especificados e número n de intervalos

29 width_bucket (x, bins)

Retorna o número do compartimento de x de acordo com os bins especificados pelos bins do array

Funções trigonométricas

Os argumentos das funções trigonométricas são representados como radianos (). A tabela a seguir lista as funções.

S.No Funções e descrição
1 acos (x)

Retorna o valor cosseno inverso (x)

2

asin(x)

Retorna o valor do seno inverso (x)

3 -

atan(x)

Retorna o valor tangente inverso (x)

4 - atan2 (y, x)

Retorna o valor tangente inverso (y / x)

5

cos(x)

Retorna o valor do cosseno (x)

6 cosh (x)

Retorna o valor do cosseno hiperbólico (x)

7 sin (x)

Retorna o valor do seno (x)

8

tan(x)

Retorna o valor tangente (x)

9

tanh(x)

Retorna o valor da tangente hiperbólica (x)

Funções bit a bit

A tabela a seguir lista as funções Bitwise.

S.No Funções e descrição
1 bit_count (x, bits)

Conte o número de bits

2 bitwise_and (x, y)

Execute a operação AND bit a bit para dois bits, x e y

3 - bitwise_or (x, y)

Operação OR bit a bit entre dois bits x, y

4 - bitwise_not (x)

Não operação bit a bit para bit x

5 bitwise_xor (x, y)

Operação XOR para bits x, y

Funções de String

A tabela a seguir lista as funções de String.

S.No Funções e descrição
1 concat (string1, ..., stringN)

Concatenar as strings fornecidas

2 comprimento (string)

Retorna o comprimento da string dada

3 - inferior (corda)

Retorna o formato de minúsculas para a string

4 - superior (corda)

Retorna o formato em maiúsculas para a string dada

5 lpad (corda, tamanho, corda)

Preenchimento esquerdo para a string dada

6 ltrim (string)

Remove o espaço em branco inicial da string

7 substituir (string, pesquisar, substituir)

Substitui o valor da string

8 reverso (string)

Reverte a operação realizada para a string

9 rpad (string, tamanho, padstring)

Preenchimento correto para a string dada

10 rtrim (string)

Remove o espaço em branco à direita da string

11 divisão (string, delimitador)

Divide a string no delimitador e retorna uma matriz de tamanho no máximo

12 split_part (string, delimitador, índice)

Divide a string no delimitador e retorna o índice do campo

13 strpos (string, substring)

Retorna a posição inicial da substring na string

14 substr (string, início)

Retorna a substring para a string fornecida

15 substr (string, início, comprimento)

Retorna a substring para a string dada com o comprimento específico

16 trim (string)

Remove o espaço em branco à esquerda e à direita da string

Funções de data e hora

A tabela a seguir lista as funções de data e hora.

S.No Funções e descrição
1 data atual

Retorna a data atual

2 hora atual

Retorna a hora atual

3 - current_timestamp

Retorna o carimbo de data / hora atual

4 - current_timezone ()

Retorna o fuso horário atual

5 agora()

Retorna a data atual, timestamp com o fuso horário

6 horário local

Retorna a hora local

7 localtimestamp

Retorna o timestamp local

Funções de expressão regular

A tabela a seguir lista as funções de Expressão Regular.

S.No Funções e descrição
1 regexp_extract_all (string, padrão)

Retorna a string correspondente à expressão regular do padrão

2 regexp_extract_all (string, padrão, grupo)

Retorna a string correspondida pela expressão regular para o padrão e o grupo

3 - regexp_extract (string, padrão)

Retorna a primeira substring correspondida pela expressão regular do padrão

4 - regexp_extract (string, padrão, grupo)

Retorna a primeira substring correspondida pela expressão regular para o padrão e o grupo

5 regexp_like (string, padrão)

Retorna as correspondências de string para o padrão. Se a string for retornada, o valor será verdadeiro, caso contrário, será falso

6 regexp_replace (string, padrão)

Substitui a instância da string correspondida à expressão pelo padrão

7 regexp_replace (string, padrão, substituição)

Substitua a instância da string correspondente à expressão pelo padrão e substituição

8 regexp_split (string, padrão)

Divide a expressão regular para o padrão fornecido

Funções JSON

The following table lists out JSON functions.

S.No Functions & Description
1. json_array_contains(json, value)

Check the value exists in a json array. If the value exists it will return true, otherwise false

2. json_array_get(json_array, index)

Get the element for index in json array

3. json_array_length(json)

Returns the length in json array

4. json_format(json)

Returns the json structure format

5. json_parse(string)

Parses the string as a json

6. json_size(json, json_path)

Returns the size of the value

URL Functions

The following table lists out the URL functions.

S.No Functions & Description
1. url_extract_host(url)

Returns the URL’s host

2. url_extract_path(url)

Returns the URL’s path

3. url_extract_port(url)

Returns the URL’s port

4. url_extract_protocol(url)

Returns the URL’s protocol

5. url_extract_query(url)

Returns the URL’s query string

Aggregate Functions

The following table lists out the Aggregate functions.

S.No Functions & Description
1.

avg(x)

Returns average for the given value

2. min(x,n)

Returns the minimum value from two values

3. max(x,n)

Returns the maximum value from two values

4. sum(x)

Returns the sum of value

5. count(*)

Returns the number of input rows

6. count(x)

Returns the count of input values

7. checksum(x)

Returns the checksum for x

8. arbitrary(x)

Returns the arbitrary value for x

Color Functions

Following table lists out the Color functions.

S.No Functions & Description
1. bar(x, width)

Renders a single bar using rgb low_color and high_color

2. bar(x, width, low_color, high_color)

Renders a single bar for the specified width

3. color(string)

Returns the color value for the entered string

4. render(x, color)

Renders value x using the specific color using ANSI color codes

5. render(b)

Accepts boolean value b and renders a green true or a red false using ANSI color codes

6.

rgb(red, green, blue)

Returns a color value capturing the RGB value of three component color values supplied as int parameters ranging from 0 to 255

Array Functions

The following table lists out the Array functions.

S.No Functions & Description
1. array_max(x)

Finds the max element in an array

2. array_min(x)

Finds the min element in an array

3. array_sort(x)

Sorts the elements in an array

4. array_remove(x,element)

Removes the specific element from an array

5. concat(x,y)

Concatenates two arrays

6. contains(x,element)

Finds the given elements in an array. True will be returned if it is present, otherwise false

7. array_position(x,element)

Find the position of the given element in an array

8. array_intersect(x,y)

Performs an intersection between two arrays

9. element_at(array,index)

Returns the array element position

10. slice(x,start,length)

Slices the array elements with the specific length

Teradata Functions

The following table lists out Teradata functions.

S.No Functions & Description
1. index(string,substring)

Returns the index of the string with the given substring

2. substring(string,start)

Returns the substring of the given string. You can specify the start index here

3. substring(string,start,length)

Returns the substring of the given string for the specific start index and length of the string

The MySQL connector is used to query an external MySQL database.

Prerequisites

MySQL server installation.

Configuration Settings

Hopefully you have installed mysql server on your machine. To enable mysql properties on Presto server, you must create a file “mysql.properties” in “etc/catalog” directory. Issue the following command to create a mysql.properties file.

$ cd etc $ cd catalog 
$ vi mysql.properties   

connector.name = mysql 
connection-url = jdbc:mysql://localhost:3306 
connection-user = root 
connection-password = pwd

Save the file and quit the terminal. In the above file, you must enter your mysql password in connection-password field.

Create Database in MySQL Server

Open MySQL server and create a database using the following command.

create database tutorials

Now you have created “tutorials” database in the server. To enable database type, use the command “use tutorials” in the query window.

Create Table

Let’s create a simple table on “tutorials” database.

create table author(auth_id int not null, auth_name varchar(50),topic varchar(100))

Insert Table

After creating a table, insert three records using the following query.

insert into author values(1,'Doug Cutting','Hadoop') 
insert into author values(2,’James Gosling','java') 
insert into author values(3,'Dennis Ritchie’,'C')

Select Records

To retrieve all the records, type the following query.

Query

select * from author

Result

auth_id    auth_name      topic  
1        Doug Cutting     Hadoop 
2        James Gosling    java 
3        Dennis Ritchie     C

As of now, you have queried data using MySQL server. Let’s connect Mysql storage plugin to Presto server.

Connect Presto CLI

Type the following command to connect MySql plugin on Presto CLI.

./presto --server localhost:8080 --catalog mysql --schema tutorials

You will receive the following response.

presto:tutorials>

Here “tutorials” refers to schema in mysql server.

List Schemas

To list out all the schemas in mysql, type the following query in Presto server.

Query

presto:tutorials> show schemas from mysql;

Result

Schema 
-------------------- 
 information_schema 
 performance_schema 
 sys 
 tutorials

From this result, we can conclude the first three schemas as predefined and the last one as created by yourself.

List Tables from Schema

Following query lists out all the tables in tutorials schema.

Query

presto:tutorials> show tables from mysql.tutorials;

Result

Table 
-------- 
 author

We have created only one table in this schema. If you have created multiple tables, it will list out all the tables.

Describe Table

To describe the table fields, type the following query.

Query

presto:tutorials> describe mysql.tutorials.author;

Result

Column   |     Type     | Comment 
-----------+--------------+--------- 
 auth_id   | integer      | 
 auth_name | varchar(50)  | 
 topic     | varchar(100) |

Show Columns from Table

Query

presto:tutorials> show columns from mysql.tutorials.author;

Result

Column    |     Type     | Comment 
-----------+--------------+--------- 
 auth_id   | integer      | 
 auth_name | varchar(50)  | 
 topic     | varchar(100) |

Access Table Records

To fetch all the records from mysql table, issue the following query.

Query

presto:tutorials> select * from mysql.tutorials.author;

Result

auth_id  |   auth_name    | topic 
---------+----------------+-------- 
       1 | Doug Cutting   | Hadoop 
       2 | James Gosling  | java 
       3 | Dennis Ritchie | C

From this result, you can retrieve mysql server records in Presto.

Create Table Using as Command

Mysql connector doesn’t support create table query but you can create a table using as command.

Query

presto:tutorials> create table mysql.tutorials.sample as 
select * from mysql.tutorials.author;

Result

CREATE TABLE: 3 rows

You can’t insert rows directly because this connector has some limitations. It cannot support the following queries −

  • create
  • insert
  • update
  • delete
  • drop

To view the records in the newly created table, type the following query.

Query

presto:tutorials> select * from mysql.tutorials.sample;

Result

auth_id  |   auth_name    | topic 
---------+----------------+-------- 
       1 | Doug Cutting   | Hadoop 
       2 | James Gosling  | java 
       3 | Dennis Ritchie | C

Java Management Extensions (JMX) gives information about the Java Virtual Machine and software running inside JVM. The JMX connector is used to query JMX information in Presto server.

As we have already enabled “jmx.properties” file under “etc/catalog” directory. Now connect Prest CLI to enable JMX plugin.

Presto CLI

Query

$ ./presto --server localhost:8080 --catalog jmx --schema jmx

Result

You will receive the following response.

presto:jmx>

JMX Schema

To list out all the schemas in “jmx”, type the following query.

Query

presto:jmx> show schemas from jmx;

Result

Schema 
-------------------- 
 information_schema  
 current

Show Tables

To view the tables in the “current” schema, use the following command.

Query 1

presto:jmx> show tables from jmx.current;

Result

Table                   
------------------------------------------------------------------------------
 com.facebook.presto.execution.scheduler:name = nodescheduler
 com.facebook.presto.execution:name = queryexecution
 com.facebook.presto.execution:name = querymanager
 com.facebook.presto.execution:name = remotetaskfactory
 com.facebook.presto.execution:name = taskexecutor
 com.facebook.presto.execution:name = taskmanager
 com.facebook.presto.execution:type = queryqueue,name = global,expansion = global
 ………………
 ……………….

Query 2

presto:jmx> select * from jmx.current.”java.lang:type = compilation";

Result

node               | compilationtimemonitoringsupported |      name   |         objectname         | totalcompilationti
--------------------------------------+------------------------------------+--------------------------------+----------------------------+-------------------
ffffffff-ffff-ffff-ffff-ffffffffffff | true | HotSpot 64-Bit Tiered Compilers | java.lang:type=Compilation |       1276

Query 3

presto:jmx> select * from jmx.current."com.facebook.presto.server:name = taskresource";

Result

node                 | readfromoutputbuffertime.alltime.count 
 | readfromoutputbuffertime.alltime.max | readfromoutputbuffertime.alltime.maxer
 --------------------------------------+---------------------------------------+--------------------------------------+--------------------------------------- 
 ffffffff-ffff-ffff-ffff-ffffffffffff |                                   92.0 |                          1.009106149 |

The Hive connector allows querying data stored in a Hive data warehouse.

Prerequisites

  • Hadoop
  • Hive

Hopefully you have installed Hadoop and Hive on your machine. Start all the services one by one in the new terminal. Then, start hive metastore using the following command,

hive --service metastore

Presto uses Hive metastore service to get the hive table’s details.

Configuration Settings

Create a file “hive.properties” under “etc/catalog” directory. Use the following command.

$ cd etc $ cd catalog 
$ vi hive.properties  

connector.name = hive-cdh4 
hive.metastore.uri = thrift://localhost:9083

After making all the changes, save the file and quit the terminal.

Create Database

Create a database in Hive using the following query −

Query

hive> CREATE SCHEMA tutorials;

After the database is created, you can verify it using the “show databases” command.

Create Table

Create Table is a statement used to create a table in Hive. For example, use the following query.

hive> create table author(auth_id int, auth_name varchar(50), 
topic varchar(100) STORED AS SEQUENCEFILE;

Insert Table

Following query is used to insert records in hive’s table.

hive> insert into table author values (1,’ Doug Cutting’,Hadoop),
(2,’ James Gosling’,java),(3,’ Dennis Ritchie’,C);

Start Presto CLI

You can start Presto CLI to connect Hive storage plugin using the following command.

$ ./presto --server localhost:8080 --catalog hive —schema tutorials;

You will receive the following response.

presto:tutorials >

List Schemas

To list out all the schemas in Hive connector, type the following command.

Query

presto:tutorials > show schemas from hive;

Result

default  

tutorials

List Tables

To list out all the tables in “tutorials” schema, use the following query.

Query

presto:tutorials > show tables from hive.tutorials;

Result

author

Fetch Table

Following query is used to fetch all the records from hive’s table.

Query

presto:tutorials > select * from hive.tutorials.author;

Result

auth_id  |   auth_name    | topic 
---------+----------------+-------- 
       1 | Doug Cutting   | Hadoop 
       2 | James Gosling  | java 
       3 | Dennis Ritchie | C

The Kafka Connector for Presto allows to access data from Apache Kafka using Presto.

Prerequisites

Download and install the latest version of the following Apache projects.

  • Apache ZooKeeper
  • Apache Kafka

Start ZooKeeper

Start ZooKeeper server using the following command.

$ bin/zookeeper-server-start.sh config/zookeeper.properties

Now, ZooKeeper starts port on 2181.

Start Kafka

Start Kafka in another terminal using the following command.

$ bin/kafka-server-start.sh config/server.properties

After kafka starts, it uses the port number 9092.

TPCH Data

Download tpch-kafka

$  curl -o kafka-tpch 
https://repo1.maven.org/maven2/de/softwareforge/kafka_tpch_0811/1.0/kafka_tpch_ 
0811-1.0.sh

Now you have downloaded the loader from Maven central using the above command. You will get a similar response as the following.

% Total    % Received % Xferd  Average Speed   Time    Time     Time  Current 
                                 Dload  Upload   Total   Spent    Left  Speed 
  0     0    0     0    0     0      0      0 --:--:--  0:00:01 --:--:--     0  
  5 21.6M    5 1279k    0     0  83898      0  0:04:30  0:00:15  0:04:15  129k
  6 21.6M    6 1407k    0     0  86656      0  0:04:21  0:00:16  0:04:05  131k  
 24 21.6M   24 5439k    0     0   124k      0  0:02:57  0:00:43  0:02:14  175k 
 24 21.6M   24 5439k    0     0   124k      0  0:02:58  0:00:43  0:02:15  160k 
 25 21.6M   25 5736k    0     0   128k      0  0:02:52  0:00:44  0:02:08  181k 
 ………………………..

Then, make it executable using the following command,

$ chmod 755 kafka-tpch

Run tpch-kafka

Run the kafka-tpch program to preload a number of topics with tpch data using the following command.

Query

$ ./kafka-tpch load --brokers localhost:9092 --prefix tpch. --tpch-type tiny

Resultado

2016-07-13T16:15:52.083+0530 INFO main io.airlift.log.Logging Logging 
to stderr
2016-07-13T16:15:52.124+0530 INFO main de.softwareforge.kafka.LoadCommand
Processing tables: [customer, orders, lineitem, part, partsupp, supplier,
nation, region]
2016-07-13T16:15:52.834+0530 INFO pool-1-thread-1
de.softwareforge.kafka.LoadCommand Loading table 'customer' into topic 'tpch.customer'...
2016-07-13T16:15:52.834+0530 INFO pool-1-thread-2
de.softwareforge.kafka.LoadCommand Loading table 'orders' into topic 'tpch.orders'...
2016-07-13T16:15:52.834+0530 INFO pool-1-thread-3
de.softwareforge.kafka.LoadCommand Loading table 'lineitem' into topic 'tpch.lineitem'...
2016-07-13T16:15:52.834+0530 INFO pool-1-thread-4
de.softwareforge.kafka.LoadCommand Loading table 'part' into topic 'tpch.part'...
………………………
……………………….

Agora, as tabelas Kafka de clientes, pedidos, fornecedor, etc., são carregadas usando tpch.

Adicionar configurações de configuração

Vamos adicionar as seguintes configurações do conector Kafka no servidor Presto.

connector.name = kafka  

kafka.nodes = localhost:9092  

kafka.table-names = tpch.customer,tpch.orders,tpch.lineitem,tpch.part,tpch.partsupp, 
tpch.supplier,tpch.nation,tpch.region  

kafka.hide-internal-columns = false

Na configuração acima, as tabelas Kafka são carregadas usando o programa Kafka-tpch.

Iniciar Presto CLI

Inicie o Presto CLI usando o seguinte comando,

$ ./presto --server localhost:8080 --catalog kafka —schema tpch;

Aqui “tpch" é um esquema para o conector Kafka e você receberá a seguinte resposta.

presto:tpch>

Listar tabelas

A consulta a seguir lista todas as tabelas em “tpch” esquema.

Inquerir

presto:tpch> show tables;

Resultado

Table 
---------- 
 customer 
 lineitem 
 nation 
 orders
 part 
 partsupp 
 region 
 supplier

Descrever a tabela do cliente

A consulta a seguir descreve “customer” mesa.

Inquerir

presto:tpch> describe customer;

Resultado

Column           |  Type   |                   Comment 
-------------------+---------+--------------------------------------------- 
 _partition_id     | bigint  | Partition Id 
 _partition_offset | bigint  | Offset for the message within the partition 
 _segment_start    | bigint  | Segment start offset 
 _segment_end      | bigint  | Segment end offset 
 _segment_count    | bigint  | Running message count per segment 
 _key              | varchar | Key text 
 _key_corrupt      | boolean | Key data is corrupt 
 _key_length       | bigint  | Total number of key bytes 
 _message          | varchar | Message text 
 _message_corrupt  | boolean | Message data is corrupt 
 _message_length   | bigint  | Total number of message bytes

A interface JDBC do Presto é usada para acessar o aplicativo Java.

Pré-requisitos

Instale presto-jdbc-0.150.jar

Você pode baixar o arquivo JDBC jar visitando o seguinte link,

https://repo1.maven.org/maven2/com/facebook/presto/presto-jdbc/0.150/

Após o download do arquivo jar, adicione-o ao caminho de classe do seu aplicativo Java.

Crie um aplicativo simples

Vamos criar um aplicativo Java simples usando a interface JDBC.

Codificação - PrestoJdbcSample.java

import java.sql.*; 
import com.facebook.presto.jdbc.PrestoDriver; 

//import presto jdbc driver packages here.  
public class PrestoJdbcSample {  
   public static void main(String[] args) {  
      Connection connection = null; 
      Statement statement = null;  
      try { 
         
         Class.forName("com.facebook.presto.jdbc.PrestoDriver");  
         connection = DriverManager.getConnection(
         "jdbc:presto://localhost:8080/mysql/tutorials", "tutorials", “"); 
         
         //connect mysql server tutorials database here 
         statement = connection.createStatement(); 
         String sql;  
         sql = "select auth_id, auth_name from mysql.tutorials.author”; 
        
         //select mysql table author table two columns  
         ResultSet resultSet = statement.executeQuery(sql);  
         while(resultSet.next()){  
            int id  = resultSet.getInt("auth_id"); 
            String name = resultSet.getString(“auth_name");  
            System.out.print("ID: " + id + ";\nName: " + name + "\n"); 
         }  
         
         resultSet.close(); 
         statement.close(); 
         connection.close(); 
         
      }catch(SQLException sqlException){ 
         sqlException.printStackTrace(); 
      }catch(Exception exception){ 
         exception.printStackTrace(); 
      } 
   } 
}

Salve o arquivo e feche o aplicativo. Agora, inicie o servidor Presto em um terminal e abra um novo terminal para compilar e executar o resultado. A seguir estão as etapas -

Compilação

~/Workspace/presto/presto-jdbc $ javac -cp presto-jdbc-0.149.jar  PrestoJdbcSample.java

Execução

~/Workspace/presto/presto-jdbc $ java -cp .:presto-jdbc-0.149.jar  PrestoJdbcSample

Resultado

INFO: Logging initialized @146ms  
ID: 1; 
Name: Doug Cutting 
ID: 2; 
Name: James Gosling 
ID: 3; 
Name: Dennis Ritchie

Crie um projeto Maven para desenvolver a função personalizada do Presto.

SimpleFunctionsFactory.java

Crie a classe SimpleFunctionsFactory para implementar a interface FunctionFactory.

package com.tutorialspoint.simple.functions;  

import com.facebook.presto.metadata.FunctionFactory; 
import com.facebook.presto.metadata.FunctionListBuilder; 
import com.facebook.presto.metadata.SqlFunction; 
import com.facebook.presto.spi.type.TypeManager;  
import java.util.List;  

public class SimpleFunctionFactory implements FunctionFactory { 
   
   private final TypeManager typeManager;  
   public SimpleFunctionFactory(TypeManager typeManager) { 
      this.typeManager = typeManager; 
   }  
    @Override 
    
   public List<SqlFunction> listFunctions() { 
      return new FunctionListBuilder(typeManager) 
      .scalar(SimpleFunctions.class) 
      .getFunctions(); 
   } 
}

SimpleFunctionsPlugin.java

Crie uma classe SimpleFunctionsPlugin para implementar a interface Plugin.

package com.tutorialspoint.simple.functions;  

import com.facebook.presto.metadata.FunctionFactory; 
import com.facebook.presto.spi.Plugin; 
import com.facebook.presto.spi.type.TypeManager; 
import com.google.common.collect.ImmutableList;  
import javax.inject.Inject; 
import java.util.List; 
import static java.util.Objects.requireNonNull;  

public class SimpleFunctionsPlugin implements Plugin {  
   private TypeManager typeManager; 
   @Inject 
   
   public void setTypeManager(TypeManager typeManager) { 
      this.typeManager = requireNonNull(typeManager, "typeManager is null”); 
      //Inject TypeManager class here 
   }  
   @Override 
   
   public <T> List<T> getServices(Class<T> type){ 
      if (type == FunctionFactory.class) { 
         return ImmutableList.of(type.cast(new SimpleFunctionFactory(typeManager))); 
      } 
      return ImmutableList.of(); 
   } 
}

Adicionar arquivo de recurso

Crie um arquivo de recursos que é especificado no pacote de implementação.

(com.tutorialspoint.simple.functions.SimpleFunctionsPlugin)

Agora vá para a localização do arquivo de recursos @ / path / to / resource /

Em seguida, adicione as alterações,

com.facebook.presto.spi.Plugin

pom.xml

Adicione as seguintes dependências ao arquivo pom.xml.

<?xml version = "1.0"?> 
<project xmlns = "http://maven.apache.org/POM/4.0.0"  
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
 xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0  
    http://maven.apache.org/xsd/maven-4.0.0.xsd">  
   
   <modelVersion>4.0.0</modelVersion> 
   <groupId>com.tutorialspoint.simple.functions</groupId> 
   <artifactId>presto-simple-functions</artifactId>  
   <packaging>jar</packaging>  
   <version>1.0</version>
   <name>presto-simple-functions</name>
   <description>Simple test functions for Presto</description> 
   <properties> 
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
   </properties>  
   <dependencies> 
      <dependency> 
         <groupId>com.facebook.presto</groupId> 
         <artifactId>presto-spi</artifactId>
         <version>0.149</version> 
      </dependency>  
      <dependency> 
         <groupId>com.facebook.presto</groupId> 
         <artifactId>presto-main</artifactId> 
         <version>0.149</version> 
      </dependency>  
      <dependency> 
         <groupId>javax.inject</groupId> 
         <artifactId>javax.inject</artifactId> 
         <version>1</version> 
      </dependency>  
      <dependency> 
         <groupId>com.google.guava</groupId> 
         <artifactId>guava</artifactId> 
         <version>19.0</version> 
      </dependency> 
   </dependencies>  
   <build> 
      <finalName>presto-simple-functions</finalName>  
      <plugins>  
      <!-- Make this jar executable --> 
         <plugin> 
            <groupId>org.apache.maven.plugins</groupId> 
            <artifactId>maven-jar-plugin</artifactId> 
            <version>2.3.2</version> 
         </plugin> 
      </plugins> 
   </build> 
</project>

SimpleFunctions.java

Crie a classe SimpleFunctions usando atributos Presto.

package com.tutorialspoint.simple.functions;  

import com.facebook.presto.operator.Description; 
import com.facebook.presto.operator.scalar.ScalarFunction; 
import com.facebook.presto.operator.scalar.StringFunctions; 
import com.facebook.presto.spi.type.StandardTypes; 
import com.facebook.presto.type.LiteralParameters; 
import com.facebook.presto.type.SqlType;  

public final class SimpleFunctions { 
   private SimpleFunctions() { 
   }  
    
   @Description("Returns summation of two numbers") 
   @ScalarFunction(“mysum") 
   //function name 
   @SqlType(StandardTypes.BIGINT) 
    
   public static long sum(@SqlType(StandardTypes.BIGINT) long num1, 
   @SqlType(StandardTypes.BIGINT) long num2) { 
      return num1 + num2; 
   } 
}

Depois que o aplicativo for criado, compile e execute o aplicativo. Ele produzirá o arquivo JAR. Copie o arquivo e mova o arquivo JAR para o diretório de plug-in do servidor Presto de destino.

Compilação

mvn compile

Execução

mvn package

Agora reinicie o servidor Presto e conecte o cliente Presto. Em seguida, execute o aplicativo de função personalizada conforme explicado abaixo,

$ ./presto --catalog mysql --schema default

Inquerir

presto:default> select mysum(10,10);

Resultado

_col0  
------- 
  20