Apache Presto - Guide rapide

L'analyse de données est le processus d'analyse des données brutes pour recueillir des informations pertinentes pour une meilleure prise de décision. Il est principalement utilisé dans de nombreuses organisations pour prendre des décisions commerciales. Eh bien, l'analyse des mégadonnées implique une grande quantité de données et ce processus est assez complexe, les entreprises utilisent donc différentes stratégies.

Par exemple, Facebook est l'une des plus grandes sociétés d'entrepôt de données au monde et basée sur les données. Les données de l'entrepôt Facebook sont stockées dans Hadoop pour des calculs à grande échelle. Plus tard, lorsque les données d'entrepôt sont devenues des pétaoctets, ils ont décidé de développer un nouveau système à faible latence. En 2012, les membres de l'équipe Facebook ont ​​conçu“Presto” pour des analyses de requêtes interactives qui fonctionneraient rapidement même avec des pétaoctets de données.

Qu'est-ce qu'Apache Presto?

Apache Presto est un moteur d'exécution de requêtes parallèle distribué, optimisé pour une faible latence et une analyse interactive des requêtes. Presto exécute les requêtes facilement et évolue sans temps d'arrêt, même de gigaoctets à pétaoctets.

Une seule requête Presto peut traiter les données de plusieurs sources telles que HDFS, MySQL, Cassandra, Hive et bien d'autres sources de données. Presto est construit en Java et facile à intégrer avec d'autres composants d'infrastructure de données. Presto est puissant et des entreprises de premier plan comme Airbnb, DropBox, Groupon, Netflix l'adoptent.

Presto - Caractéristiques

Presto contient les fonctionnalités suivantes -

  • Architecture simple et extensible.
  • Connecteurs enfichables - Presto prend en charge les connecteurs enfichables pour fournir des métadonnées et des données pour les requêtes.
  • Exécutions en pipeline: évite la surcharge de latence d'E / S inutile.
  • Fonctions définies par l'utilisateur - Les analystes peuvent créer des fonctions personnalisées définies par l'utilisateur pour migrer facilement.
  • Traitement colonnaire vectorisé.

Presto - Avantages

Voici une liste des avantages qu'offre Apache Presto -

  • Opérations SQL spécialisées
  • Facile à installer et à déboguer
  • Abstraction de stockage simple
  • Met rapidement à l'échelle les données de pétaoctets avec une faible latence

Presto - Applications

Presto prend en charge la plupart des meilleures applications industrielles d'aujourd'hui. Jetons un coup d'œil à certaines des applications notables.

  • Facebook- Facebook a construit Presto pour les besoins d'analyse de données. Presto met facilement à l'échelle une grande vitesse de données.

  • Teradata- Teradata fournit des solutions de bout en bout dans l'analyse Big Data et l'entreposage de données. La contribution de Teradata à Presto permet à davantage d'entreprises de répondre à tous les besoins analytiques.

  • Airbnb- Presto fait partie intégrante de l'infrastructure de données Airbnb. Eh bien, des centaines d'employés exécutent des requêtes chaque jour avec la technologie.

Pourquoi Presto?

Presto prend en charge la norme ANSI SQL, ce qui a rendu la tâche très facile pour les analystes de données et les développeurs. Bien qu'il soit construit en Java, il évite les problèmes typiques de code Java liés à l'allocation de mémoire et au garbage collection. Presto a une architecture de connecteur compatible avec Hadoop. Il permet de brancher facilement des systèmes de fichiers.

Presto fonctionne sur plusieurs distributions Hadoop. De plus, Presto peut accéder à partir d'une plateforme Hadoop pour interroger Cassandra, des bases de données relationnelles ou d'autres magasins de données. Cette capacité d'analyse multiplateforme permet aux utilisateurs de Presto d'extraire une valeur commerciale maximale de gigaoctets à pétaoctets de données.

L'architecture de Presto est presque similaire à l'architecture SGBD MPP (traitement massivement parallèle) classique. Le diagramme suivant illustre l'architecture de Presto.

Le diagramme ci-dessus se compose de différents composants. Le tableau suivant décrit chacun des composants en détail.

S. Non Composant et description
1.

Client

Le client (Presto CLI) soumet des instructions SQL à un coordinateur pour obtenir le résultat.

2.

Coordinator

Le coordinateur est un démon maître. Le coordinateur analyse d'abord les requêtes SQL, puis analyse et planifie l'exécution de la requête. Scheduler exécute le pipeline, attribue le travail au nœud le plus proche et surveille la progression.

3.

Connector

Les plugins de stockage sont appelés connecteurs. Hive, HBase, MySQL, Cassandra et bien d'autres font office de connecteur; sinon, vous pouvez également en implémenter un personnalisé. Le connecteur fournit des métadonnées et des données pour les requêtes. Le coordinateur utilise le connecteur pour obtenir des métadonnées afin de créer un plan de requête.

4.

Worker

Le coordinateur affecte la tâche aux nœuds de calcul. Les travailleurs obtiennent les données réelles du connecteur. Enfin, le nœud worker fournit le résultat au client.

Presto - Flux de travail

Presto est un système distribué qui s'exécute sur un cluster de nœuds. Le moteur de requête distribué de Presto est optimisé pour l'analyse interactive et prend en charge le SQL ANSI standard, y compris les requêtes complexes, les agrégations, les jointures et les fonctions de fenêtre. L'architecture Presto est simple et extensible. Le client Presto (CLI) soumet des instructions SQL à un coordinateur de démon maître.

Le planificateur se connecte via le pipeline d'exécution. Le planificateur affecte le travail aux nœuds les plus proches des données et surveille la progression. Le coordinateur affecte la tâche à plusieurs nœuds de travail et enfin le nœud de travail renvoie le résultat au client. Le client extrait les données du processus de sortie. L'extensibilité est la conception clé. Les connecteurs enfichables tels que Hive, HBase, MySQL, etc., fournissent des métadonnées et des données pour les requêtes. Presto a été conçu avec une «abstraction de stockage simple» qui permet de fournir facilement une capacité de requête SQL sur ces différents types de sources de données.

Modèle d'exécution

Presto prend en charge le moteur de requête et d'exécution personnalisé avec des opérateurs conçus pour prendre en charge la sémantique SQL. Outre une planification améliorée, tous les traitements sont en mémoire et acheminés sur le réseau entre les différentes étapes. Cela évite une surcharge de latence d'E / S inutile.

Ce chapitre explique comment installer Presto sur votre machine. Passons en revue les exigences de base de Presto,

  • Linux ou Mac OS
  • Java version 8

Maintenant, continuons les étapes suivantes pour installer Presto sur votre machine.

Vérification de l'installation de Java

Espérons que vous avez déjà installé la version 8 de Java sur votre ordinateur, vous n'avez donc qu'à le vérifier à l'aide de la commande suivante.

$ java -version

Si Java est correctement installé sur votre ordinateur, vous pouvez voir la version de Java installé. Si Java n'est pas installé, suivez les étapes suivantes pour installer Java 8 sur votre machine.

Téléchargez JDK. Téléchargez la dernière version de JDK en visitant le lien suivant.

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

La dernière version est JDK 8u 92 et le fichier est «jdk-8u92-linux-x64.tar.gz». Veuillez télécharger le fichier sur votre machine.

Après cela, extrayez les fichiers et déplacez-vous vers le répertoire spécifique.

Ensuite, définissez des alternatives Java. Enfin Java sera installé sur votre machine.

Installation d'Apache Presto

Téléchargez la dernière version de Presto en visitant le lien suivant,

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

Maintenant, la dernière version de «presto-server-0.149.tar.gz» sera téléchargée sur votre machine.

Extraire les fichiers tar

Extraire le tar fichier à l'aide de la commande suivante -

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

Paramètres de configuration

Créer un répertoire «data»

Créez un répertoire de données en dehors du répertoire d'installation, qui sera utilisé pour stocker les journaux, les métadonnées, etc., afin qu'il soit facilement préservé lors de la mise à niveau de Presto. Il est défini à l'aide du code suivant -

$ cd  
$ mkdir data

Pour afficher le chemin où il se trouve, utilisez la commande «pwd». Cet emplacement sera attribué dans le fichier node.properties suivant.

Créer le répertoire «etc»

Créez un répertoire etc dans le répertoire d'installation de Presto en utilisant le code suivant -

$ cd presto-server-0.149 
$ mkdir etc

Ce répertoire contiendra les fichiers de configuration. Créons chaque fichier un par un.

Propriétés du nœud

Le fichier de propriétés du nœud Presto contient la configuration environnementale spécifique à chaque nœud. Il est créé dans le répertoire etc (etc / node.properties) en utilisant le code suivant -

$ cd etc 
$ vi node.properties  

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

Après avoir effectué toutes les modifications, enregistrez le fichier et quittez le terminal. Icinode.data est le chemin de l'emplacement du répertoire de données créé ci-dessus. node.id représente l'identifiant unique de chaque nœud.

Configuration JVM

Créez un fichier «jvm.config» dans le répertoire etc (etc / jvm.config). Ce fichier contient une liste d'options de ligne de commande utilisées pour lancer la machine virtuelle Java.

$ cd etc 
$ vi jvm.config  

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

Après avoir effectué toutes les modifications, enregistrez le fichier et quittez le terminal.

Propriétés de configuration

Créez un fichier «config.properties» dans le répertoire etc (etc / config.properties). Ce fichier contient la configuration du serveur Presto. Si vous configurez une seule machine pour les tests, le serveur Presto ne peut fonctionner que comme processus de coordination tel que défini à l'aide du code suivant -

$ 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

Ici,

  • coordinator - nœud maître.

  • node-scheduler.include-coordinator - Permet de planifier le travail sur le coordinateur.

  • http-server.http.port - Spécifie le port du serveur HTTP.

  • query.max-memory=5GB - La quantité maximale de mémoire distribuée.

  • query.max-memory-per-node=1GB - La quantité maximale de mémoire par nœud.

  • discovery-server.enabled - Presto utilise le service Discovery pour trouver tous les nœuds du cluster.

  • discovery.uri - l'URI du serveur Discovery.

Si vous configurez plusieurs serveurs Presto de machines, Presto fonctionnera à la fois comme processus de coordination et de travail. Utilisez ce paramètre de configuration pour tester le serveur Presto sur plusieurs machines.

Configuration pour le coordinateur

$ 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

Configuration pour le travailleur

$ 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

Propriétés du journal

Créez un fichier «log.properties» dans le répertoire etc (etc / log.properties). Ce fichier contient le niveau de journalisation minimum pour les hiérarchies de journalisation nommées. Il est défini à l'aide du code suivant -

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

Enregistrez le fichier et quittez le terminal. Ici, quatre niveaux de journalisation sont utilisés tels que DEBUG, INFO, WARN et ERROR. Le niveau de journal par défaut est INFO.

Propriétés du catalogue

Créez un répertoire «catalogue» dans le répertoire etc (etc / catalog). Cela sera utilisé pour le montage des données. Par exemple, créezetc/catalog/jmx.properties avec le contenu suivant pour monter le jmx connector comme le catalogue jmx -

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

Démarrez Presto

Presto peut être démarré à l'aide de la commande suivante,

$ bin/launcher start

Ensuite, vous verrez la réponse similaire à celle-ci,

Started as 840

Exécutez Presto

Pour lancer le serveur Presto, utilisez la commande suivante -

$ bin/launcher run

Après avoir lancé avec succès le serveur Presto, vous pouvez trouver les fichiers journaux dans le répertoire «var / log».

  • launcher.log - Ce journal est créé par le lanceur et est connecté aux flux stdout et stderr du serveur.

  • server.log - Il s'agit du fichier journal principal utilisé par Presto.

  • http-request.log - Requête HTTP reçue par le serveur.

À partir de maintenant, vous avez installé avec succès les paramètres de configuration Presto sur votre machine. Continuons les étapes pour installer Presto CLI.

Installez Presto CLI

La CLI Presto fournit un shell interactif basé sur un terminal pour exécuter des requêtes.

Téléchargez la CLI Presto en visitant le lien suivant,

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

Maintenant, «presto-cli-0.149-executable.jar» sera installé sur votre machine.

Exécutez CLI

Après avoir téléchargé le presto-cli, copiez-le vers l'emplacement à partir duquel vous souhaitez l'exécuter. Cet emplacement peut être n'importe quel nœud ayant un accès réseau au coordinateur. Commencez par changer le nom du fichier Jar en Presto. Ensuite, rendez-le exécutable avecchmod + x commande en utilisant le code suivant -

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

Exécutez maintenant CLI à l'aide de la commande suivante,

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

Vous verrez la réponse suivante,

presto:default>

Tapez maintenant la commande «jps» sur votre terminal et vous verrez les démons en cours d'exécution.

Arrêtez Presto

Après avoir effectué toutes les exécutions, vous pouvez arrêter le serveur presto à l'aide de la commande suivante -

$ bin/launcher stop

Ce chapitre abordera les paramètres de configuration de Presto.

Vérificateur Presto

Le Presto Verifier peut être utilisé pour tester Presto par rapport à une autre base de données (telle que MySQL), ou pour tester deux clusters Presto l'un par rapport à l'autre.

Créer une base de données dans MySQL

Ouvrez le serveur MySQL et créez une base de données à l'aide de la commande suivante.

create database test

Vous avez maintenant créé la base de données «test» sur le serveur. Créez la table et chargez-la avec la requête suivante.

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) 
);

Ajouter des paramètres de configuration

Créez un fichier de propriétés pour configurer le vérificateur -

$ 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

Ici, dans le query-database champ, entrez les détails suivants - nom de la base de données mysql, nom d'utilisateur et mot de passe.

Télécharger le fichier JAR

Téléchargez le fichier jar Presto-verifier en visitant le lien suivant,

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

Maintenant la version “presto-verifier-0.149-executable.jar” est téléchargé sur votre machine.

Exécuter le JAR

Exécutez le fichier JAR à l'aide de la commande suivante,

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

Exécuter le vérificateur

Exécutez le vérificateur à l'aide de la commande suivante,

$ ./verifier config.properties

Créer une table

Créons un tableau simple dans “test” base de données à l'aide de la requête suivante.

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

Insérer un tableau

Après avoir créé une table, insérez deux enregistrements à l'aide de la requête suivante,

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

Exécuter la requête du vérificateur

Exécutez l'exemple de requête suivant dans le terminal du vérificateur (./verifier config.propeties) pour vérifier le résultat du vérificateur.

Exemple de requête

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');

Ici, select * from mysql.test.product la requête fait référence au catalogue mysql, test est le nom de la base de données et productest le nom de la table. De cette façon, vous pouvez accéder au connecteur mysql en utilisant le serveur Presto.

Ici, deux mêmes requêtes de sélection sont testées l'une par rapport à l'autre pour voir les performances. De même, vous pouvez exécuter d'autres requêtes pour tester les résultats de performances. Vous pouvez également connecter deux clusters Presto pour vérifier les résultats de performances.

Dans ce chapitre, nous aborderons les outils d'administration utilisés dans Presto. Commençons par l'interface Web de Presto.

Interface Web

Presto fournit une interface Web pour surveiller et gérer les requêtes. Il est accessible à partir du numéro de port spécifié dans les propriétés de configuration du coordinateur.

Démarrez le serveur Presto et la CLI Presto. Ensuite, vous pouvez accéder à l'interface Web à partir de l'url suivante -http://localhost:8080/

La sortie sera similaire à l'écran ci-dessus.

Ici, la page principale contient une liste de requêtes ainsi que des informations telles que l'ID de requête unique, le texte de la requête, l'état de la requête, le pourcentage achevé, le nom d'utilisateur et la source d'où provient cette requête. Les dernières requêtes s'exécutent en premier, puis les requêtes terminées ou non terminées sont affichées en bas.

Réglage des performances sur Presto

Si le cluster Presto rencontre des problèmes de performances, modifiez vos paramètres de configuration par défaut pour les paramètres suivants.

Propriétés de configuration

  • task. info -refresh-max-wait - Réduit la charge de travail du coordinateur.

  • task.max-worker-threads - Divise le processus et affecte à chaque nœud de travail.

  • distributed-joins-enabled - Jointures distribuées basées sur le hachage.

  • node-scheduler.network-topology - Définit la topologie du réseau sur le planificateur.

Paramètres JVM

Modifiez vos paramètres JVM par défaut pour les paramètres suivants. Cela sera utile pour diagnostiquer les problèmes de garbage collection.

-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

Dans ce chapitre, nous verrons comment créer et exécuter des requêtes sur Presto. Passons en revue les types de données de base pris en charge par Presto.

Types de données de base

Le tableau suivant décrit les types de données de base de Presto.

S. Non Type de données et description
1.

VARCHAR

Données de caractères de longueur variable

2.

BIGINT

Un entier signé 64 bits

3.

DOUBLE

Une valeur de double précision à virgule flottante 64 bits

4.

DECIMAL

Un nombre décimal de précision fixe. Par exemple, DECIMAL (10,3) - 10 est la précision, c'est-à-dire le nombre total de chiffres et 3 est la valeur d'échelle représentée sous forme de point fractionnaire. L'échelle est facultative et la valeur par défaut est 0

5.

BOOLEAN

Valeurs booléennes true et false

6.

VARBINARY

Données binaires de longueur variable

sept.

JSON

Données JSON

8.

DATE

Type de données de date représenté par année-mois-jour

9.

TIME, TIMESTAMP, TIMESTAMP with TIME ZONE

TIME - Heure de la journée (heure-min-sec-milliseconde)

TIMESTAMP - Date et heure du jour

TIMESTAMP with TIME ZONE - Date et heure du jour avec fuseau horaire de la valeur

dix.

INTERVAL

Étirer ou prolonger les types de données de date et d'heure

11.

ARRAY

Tableau du type de composant donné. Par exemple, ARRAY [5,7]

12.

MAP

Mapper entre les types de composants donnés. Par exemple, MAP (ARRAY ['one', 'two'], ARRAY [5,7])

13.

ROW

Structure de ligne composée de champs nommés

Presto - Opérateurs

Les opérateurs Presto sont répertoriés dans le tableau suivant.

S. Non Opérateur et description
1. Opérateur arithmétique

Presto prend en charge les opérateurs arithmétiques tels que +, -, *, /,%

2. Opérateur relationnel

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

3. Opérateur logique

ET, OU, PAS

4. Opérateur de gamme

L'opérateur de plage est utilisé pour tester la valeur dans une plage spécifique. Presto prend en charge BETWEEN, IS NULL, IS NOT NULL, GREATEST and MOINS

5. Opérateur décimal

Opérateur décimal arithmétique binaire effectue une opération arithmétique binaire pour le type décimal Opérateur décimal unaire - Le - operator effectue la négation

6. Opérateur de chaîne

le ‘||’ operator effectue la concaténation de chaînes

sept. Opérateur de date et d'heure

Effectue des opérations d'addition et de soustraction arithmétiques sur les types de données de date et d'heure

8. Opérateur de tableau

Opérateur d'indice [] - accéder à un élément d'un tableau

Opérateur de concaténation || - concaténer un tableau avec un tableau ou un élément du même type

9. Opérateur de carte

Opérateur d'indice de carte [] - récupère la valeur correspondant à une clé donnée à partir d'une carte

À partir de maintenant, nous discutions d'exécuter quelques requêtes de base simples sur Presto. Ce chapitre abordera les fonctions SQL importantes.

Fonctions mathématiques

Les fonctions mathématiques fonctionnent sur des formules mathématiques. Le tableau suivant décrit la liste des fonctions en détail.

S.No. Description de la fonction
1. abs (x)

Renvoie la valeur absolue de x

2. cbrt (x)

Renvoie la racine cubique de x

3. plafond (x)

Renvoie le x valeur arrondie à l'entier supérieur le plus proche

4.

ceil(x)

Alias ​​pour plafond (x)

5. degrés (x)

Renvoie la valeur du degré pour x

6. ex)

Renvoie la valeur double du nombre d'Euler

sept.

exp(x)

Renvoie la valeur de l'exposant pour le nombre d'Euler

8. plancher (x)

Retour x arrondi à l'entier inférieur le plus proche

9.

from_base(string,radix)

Renvoie la valeur de la chaîne interprétée comme un nombre de base de base

dix.

ln(x)

Renvoie le logarithme naturel de x

11. log2 (x)

Renvoie le logarithme de base 2 de x

12.

log10(x)

Renvoie le logarithme en base 10 de x

13.

log(x,y)

Renvoie la base y logarithme de x

14. mod (n, m)

Renvoie le module (reste) de n divisé par m

15.

pi()

Renvoie la valeur pi. Le résultat sera renvoyé sous forme de valeur double

16. puissance (x, p)

Renvoie la puissance de la valeur ‘p’ à la x valeur

17.

pow(x,p)

Alias ​​pour le pouvoir (x, p)

18. radians (x)

convertit l'angle x en degrés radians

19.

rand()

Alias ​​pour radians ()

20. Aléatoire()

Renvoie la valeur pseudo-aléatoire

21.

rand(n)

Alias ​​pour aléatoire ()

22. rond (x)

Renvoie la valeur arrondie pour x

23.

round(x,d)

x valeur arrondie pour le ‘d’ décimales

24.

sign(x)

Renvoie la fonction signum de x, c'est-à-dire

0 si l'argument est 0

1 si l'argument est supérieur à 0

-1 si l'argument est inférieur à 0

Pour les arguments doubles, la fonction renvoie en plus -

NaN si l'argument est NaN

1 si l'argument est + Infinity

-1 si l'argument est -Infinity

25. sqrt (x)

Renvoie la racine carrée de x

26. to_base (x, base)

Le type de retour est archer. Le résultat est renvoyé comme base de base pourx

27. tronquer (x)

Tronque la valeur de x

28. width_bucket (x, borne1, borne2, n)

Renvoie le numéro de casier de x limites bound1 et bound2 spécifiées et nombre n de compartiments

29. width_bucket (x, bacs)

Renvoie le numéro de casier de x selon les bins spécifiés par les bins du tableau

Fonctions trigonométriques

Les arguments des fonctions trigonométriques sont représentés par des radians (). Le tableau suivant répertorie les fonctions.

S. Non Fonctions et description
1. acos (x)

Renvoie la valeur du cosinus inverse (x)

2.

asin(x)

Renvoie la valeur sinusoïdale inverse (x)

3.

atan(x)

Renvoie la valeur de la tangente inverse (x)

4. atan2 (y, x)

Renvoie la valeur de la tangente inverse (y / x)

5.

cos(x)

Renvoie la valeur cosinus (x)

6. cosh (x)

Renvoie la valeur du cosinus hyperbolique (x)

sept. sin (x)

Renvoie la valeur sinusoïdale (x)

8.

tan(x)

Renvoie la valeur tangente (x)

9.

tanh(x)

Renvoie la valeur de tangente hyperbolique (x)

Fonctions au niveau du bit

Le tableau suivant répertorie les fonctions Bitwise.

S. Non Fonctions et description
1. nombre_bits (x, bits)

Comptez le nombre de bits

2. bitwise_and (x, y)

Effectuer une opération ET au niveau du bit pour deux bits, x et y

3. bitwise_or (x, y)

Opération OR au niveau du bit entre deux bits x, y

4. bitwise_not (x)

Bitwise Pas d'opération pour bit x

5. bitwise_xor (x, y)

Opération XOR pour les bits x, y

Fonctions de chaîne

Le tableau suivant répertorie les fonctions de chaîne.

S. Non Fonctions et description
1. concat (chaîne1, ..., chaîneN)

Concaténer les chaînes données

2. longueur (chaîne)

Renvoie la longueur de la chaîne donnée

3. inférieur (chaîne)

Renvoie le format minuscule de la chaîne

4. supérieur (chaîne)

Renvoie le format en majuscules pour la chaîne donnée

5. lpad (chaîne, taille, padstring)

Remplissage à gauche pour la chaîne donnée

6. ltrim (chaîne)

Supprime le premier espace blanc de la chaîne

sept. replace (chaîne, recherche, remplacement)

Remplace la valeur de chaîne

8. reverse (chaîne)

Inverse l'opération effectuée pour la chaîne

9. rpad (chaîne, taille, padstring)

Remplissage droit pour la chaîne donnée

dix. rtrim (chaîne)

Supprime l'espace blanc de fin de la chaîne

11. split (chaîne, délimiteur)

Divise la chaîne sur le délimiteur et renvoie un tableau de taille au maximum

12. split_part (chaîne, délimiteur, index)

Divise la chaîne sur le délimiteur et renvoie l'index du champ

13. strpos (chaîne, sous-chaîne)

Renvoie la position de départ de la sous-chaîne dans la chaîne

14. substr (chaîne, début)

Renvoie la sous-chaîne de la chaîne donnée

15. substr (chaîne, début, longueur)

Renvoie la sous-chaîne de la chaîne donnée avec la longueur spécifique

16. trim (chaîne)

Supprime les espaces de début et de fin de la chaîne

Fonctions de date et d'heure

Le tableau suivant répertorie les fonctions de date et d'heure.

S. Non Fonctions et description
1. date actuelle

Renvoie la date actuelle

2. heure actuelle

Renvoie l'heure actuelle

3. current_timestamp

Renvoie l'horodatage actuel

4. current_timezone ()

Renvoie le fuseau horaire actuel

5. maintenant()

Renvoie la date actuelle, l'horodatage avec le fuseau horaire

6. heure locale

Renvoie l'heure locale

sept. horodatage local

Renvoie l'horodatage local

Fonctions d'expression régulière

Le tableau suivant répertorie les fonctions d'expressions régulières.

S. Non Fonctions et description
1. regexp_extract_all (chaîne, modèle)

Renvoie la chaîne correspondant à l'expression régulière du modèle

2. regexp_extract_all (chaîne, modèle, groupe)

Renvoie la chaîne correspondant à l'expression régulière pour le modèle et le groupe

3. regexp_extract (chaîne, modèle)

Renvoie la première sous-chaîne correspondant à l'expression régulière du modèle

4. regexp_extract (chaîne, modèle, groupe)

Renvoie la première sous-chaîne correspondant à l'expression régulière pour le modèle et le groupe

5. regexp_like (chaîne, modèle)

Renvoie la chaîne correspondant au modèle. Si la chaîne est retournée, la valeur sera true sinon false

6. regexp_replace (chaîne, modèle)

Remplace l'instance de la chaîne correspondant à l'expression par le modèle

sept. regexp_replace (chaîne, modèle, remplacement)

Remplacez l'instance de la chaîne correspondant à l'expression par le modèle et le remplacement

8. regexp_split (chaîne, modèle)

Divise l'expression régulière pour le modèle donné

Fonctions JSON

Le tableau suivant répertorie les fonctions JSON.

S. Non Fonctions et description
1. json_array_contains (json, valeur)

Vérifiez que la valeur existe dans un tableau json. Si la valeur existe, elle retournera vrai, sinon faux

2. json_array_get (json_array, index)

Récupère l'élément pour l'index dans le tableau json

3. json_array_length (json)

Renvoie la longueur dans le tableau json

4. json_format (json)

Renvoie le format de structure json

5. json_parse (chaîne)

Analyse la chaîne en tant que json

6. json_size (json, json_path)

Renvoie la taille de la valeur

Fonctions URL

Le tableau suivant répertorie les fonctions URL.

S. Non Fonctions et description
1. url_extract_host (url)

Renvoie l'hôte de l'URL

2. url_extract_path (url)

Renvoie le chemin de l'URL

3. url_extract_port (url)

Renvoie le port de l'URL

4. url_extract_protocol (url)

Renvoie le protocole de l'URL

5. url_extract_query (url)

Renvoie la chaîne de requête de l'URL

Fonctions d'agrégation

Le tableau suivant répertorie les fonctions d'agrégation.

S. Non Fonctions et description
1.

avg(x)

Renvoie la moyenne pour la valeur donnée

2. min (x, n)

Renvoie la valeur minimale de deux valeurs

3. max (x, n)

Renvoie la valeur maximale de deux valeurs

4. somme (x)

Renvoie la somme de la valeur

5. compter(*)

Renvoie le nombre de lignes d'entrée

6. compter (x)

Renvoie le nombre de valeurs d'entrée

sept. somme de contrôle (x)

Renvoie la somme de contrôle pour x

8. arbitraire (x)

Renvoie la valeur arbitraire de x

Fonctions de couleur

Le tableau suivant répertorie les fonctions de couleur.

S. Non Fonctions et description
1. barre (x, largeur)

Rend une seule barre en utilisant rgb low_color et high_color

2. barre (x, largeur, low_color, high_color)

Rend une seule barre pour la largeur spécifiée

3. couleur (chaîne)

Renvoie la valeur de couleur pour la chaîne saisie

4. rendu (x, couleur)

Rend la valeur x en utilisant la couleur spécifique à l'aide des codes de couleur ANSI

5. rendre (b)

Accepte la valeur booléenne b et rend un vert vrai ou un rouge faux à l'aide des codes de couleur ANSI

6.

rgb(red, green, blue)

Renvoie une valeur de couleur capturant la valeur RVB de trois valeurs de couleur de composant fournies en tant que paramètres int allant de 0 à 255

Fonctions de tableau

Le tableau suivant répertorie les fonctions Array.

S. Non Fonctions et description
1. array_max (x)

Recherche l'élément max dans un tableau

2. array_min (x)

Recherche l'élément min dans un tableau

3. array_sort (x)

Trie les éléments dans un tableau

4. array_remove (x, élément)

Supprime l'élément spécifique d'un tableau

5. concat (x, y)

Concatène deux tableaux

6. contient (x, élément)

Recherche les éléments donnés dans un tableau. True sera retourné s'il est présent, sinon faux

sept. array_position (x, élément)

Trouvez la position de l'élément donné dans un tableau

8. array_intersect (x, y)

Effectue une intersection entre deux tableaux

9. element_at (tableau, index)

Renvoie la position de l'élément du tableau

dix. tranche (x, début, longueur)

Découpe les éléments du tableau avec la longueur spécifique

Fonctions Teradata

Le tableau suivant répertorie les fonctions Teradata.

S. Non Fonctions et description
1. index (chaîne, sous-chaîne)

Renvoie l'index de la chaîne avec la sous-chaîne donnée

2. sous-chaîne (chaîne, début)

Renvoie la sous-chaîne de la chaîne donnée. Vous pouvez spécifier ici l'index de départ

3. sous-chaîne (chaîne, début, longueur)

Renvoie la sous-chaîne de la chaîne donnée pour l'index de début spécifique et la longueur de la chaîne

Le connecteur MySQL est utilisé pour interroger une base de données MySQL externe.

Conditions préalables

Installation du serveur MySQL.

Paramètres de configuration

J'espère que vous avez installé le serveur mysql sur votre machine. Pour activer les propriétés mysql sur le serveur Presto, vous devez créer un fichier“mysql.properties” dans “etc/catalog”annuaire. Exécutez la commande suivante pour créer un fichier mysql.properties.

$ cd etc $ cd catalog 
$ vi mysql.properties   

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

Enregistrez le fichier et quittez le terminal. Dans le fichier ci-dessus, vous devez entrer votre mot de passe mysql dans le champ login-password.

Créer une base de données dans MySQL Server

Ouvrez le serveur MySQL et créez une base de données à l'aide de la commande suivante.

create database tutorials

Vous avez maintenant créé une base de données «didacticiels» sur le serveur. Pour activer le type de base de données, utilisez la commande «utiliser des didacticiels» dans la fenêtre de requête.

Créer une table

Créons un tableau simple sur la base de données «tutoriels».

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

Insérer un tableau

Après avoir créé une table, insérez trois enregistrements à l'aide de la requête suivante.

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

Sélectionner des enregistrements

Pour récupérer tous les enregistrements, tapez la requête suivante.

Requete

select * from author

Résultat

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

À partir de maintenant, vous avez interrogé des données à l'aide du serveur MySQL. Connectons le plugin de stockage Mysql au serveur Presto.

Connectez Presto CLI

Tapez la commande suivante pour connecter le plugin MySql sur Presto CLI.

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

Vous recevrez la réponse suivante.

presto:tutorials>

Ici “tutorials” fait référence au schéma du serveur mysql.

Répertorier les schémas

Pour lister tous les schémas de mysql, tapez la requête suivante sur le serveur Presto.

Requete

presto:tutorials> show schemas from mysql;

Résultat

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

De ce résultat, nous pouvons conclure les trois premiers schémas comme prédéfinis et le dernier comme créé par vous-même.

Lister les tables à partir du schéma

La requête suivante répertorie toutes les tables du schéma des didacticiels.

Requete

presto:tutorials> show tables from mysql.tutorials;

Résultat

Table 
-------- 
 author

Nous n'avons créé qu'une seule table dans ce schéma. Si vous avez créé plusieurs tables, toutes les tables seront répertoriées.

Décrire le tableau

Pour décrire les champs de la table, saisissez la requête suivante.

Requete

presto:tutorials> describe mysql.tutorials.author;

Résultat

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

Afficher les colonnes de la table

Requete

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

Résultat

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

Accéder aux enregistrements de la table

Pour récupérer tous les enregistrements de la table mysql, lancez la requête suivante.

Requete

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

Résultat

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

À partir de ce résultat, vous pouvez récupérer les enregistrements du serveur mysql dans Presto.

Créer une table en utilisant comme commande

Le connecteur Mysql ne prend pas en charge la requête de création de table, mais vous pouvez créer une table en utilisant la commande as.

Requete

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

Résultat

CREATE TABLE: 3 rows

Vous ne pouvez pas insérer de lignes directement car ce connecteur présente certaines limitations. Il ne peut pas prendre en charge les requêtes suivantes -

  • create
  • insert
  • update
  • delete
  • drop

Pour afficher les enregistrements de la table nouvellement créée, tapez la requête suivante.

Requete

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

Résultat

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

Les extensions de gestion Java (JMX) fournissent des informations sur la machine virtuelle Java et les logiciels exécutés dans JVM. Le connecteur JMX est utilisé pour interroger les informations JMX dans le serveur Presto.

Comme nous l'avons déjà activé “jmx.properties” fichier sous “etc/catalog”annuaire. Connectez maintenant la CLI Prest pour activer le plugin JMX.

CLI Presto

Requete

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

Résultat

Vous recevrez la réponse suivante.

presto:jmx>

Schéma JMX

Pour lister tous les schémas dans «jmx», tapez la requête suivante.

Requete

presto:jmx> show schemas from jmx;

Résultat

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

Afficher les tableaux

Pour afficher les tables dans le schéma «actuel», utilisez la commande suivante.

Requête 1

presto:jmx> show tables from jmx.current;

Résultat

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
 ………………
 ……………….

Requête 2

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

Résultat

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

Requête 3

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

Résultat

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

Le connecteur Hive permet d'interroger les données stockées dans un entrepôt de données Hive.

Conditions préalables

  • Hadoop
  • Hive

J'espère que vous avez installé Hadoop et Hive sur votre machine. Démarrez tous les services un par un dans le nouveau terminal. Ensuite, démarrez Hive Metastore à l'aide de la commande suivante,

hive --service metastore

Presto utilise le service de métastore Hive pour obtenir les détails de la table Hive.

Paramètres de configuration

Créer un fichier “hive.properties” en dessous de “etc/catalog”annuaire. Utilisez la commande suivante.

$ cd etc $ cd catalog 
$ vi hive.properties  

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

Après avoir effectué toutes les modifications, enregistrez le fichier et quittez le terminal.

Créer une base de données

Créez une base de données dans Hive à l'aide de la requête suivante -

Requete

hive> CREATE SCHEMA tutorials;

Une fois la base de données créée, vous pouvez la vérifier à l'aide du “show databases” commander.

Créer une table

Create Table est une instruction utilisée pour créer une table dans Hive. Par exemple, utilisez la requête suivante.

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

Insérer un tableau

La requête suivante est utilisée pour insérer des enregistrements dans la table de la ruche.

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

Démarrez Presto CLI

Vous pouvez démarrer Presto CLI pour connecter le plugin de stockage Hive à l'aide de la commande suivante.

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

Vous recevrez la réponse suivante.

presto:tutorials >

Répertorier les schémas

Pour répertorier tous les schémas du connecteur Hive, saisissez la commande suivante.

Requete

presto:tutorials > show schemas from hive;

Résultat

default  

tutorials

Tables de liste

Pour lister toutes les tables dans le schéma «tutoriels», utilisez la requête suivante.

Requete

presto:tutorials > show tables from hive.tutorials;

Résultat

author

Récupérer la table

La requête suivante est utilisée pour récupérer tous les enregistrements de la table de la ruche.

Requete

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

Résultat

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

Le connecteur Kafka pour Presto permet d'accéder aux données d'Apache Kafka en utilisant Presto.

Conditions préalables

Téléchargez et installez la dernière version des projets Apache suivants.

  • Apache ZooKeeper
  • Apache Kafka

Démarrez ZooKeeper

Démarrez le serveur ZooKeeper à l'aide de la commande suivante.

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

Maintenant, ZooKeeper démarre le port sur 2181.

Démarrez Kafka

Démarrez Kafka dans un autre terminal à l'aide de la commande suivante.

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

Après le démarrage de kafka, il utilise le numéro de port 9092.

Données TPCH

Télécharger tpch-kafka

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

Vous avez maintenant téléchargé le chargeur depuis Maven central en utilisant la commande ci-dessus. Vous obtiendrez une réponse similaire à la suivante.

% 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 
 ………………………..

Ensuite, rendez-le exécutable à l'aide de la commande suivante,

$ chmod 755 kafka-tpch

Exécutez tpch-kafka

Exécutez le programme kafka-tpch pour précharger un certain nombre de rubriques avec des données tpch à l'aide de la commande suivante.

Requete

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

Résultat

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'...
………………………
……………………….

Désormais, les clients, commandes, fournisseurs, etc. des tables Kafka sont chargés à l'aide de tpch.

Ajouter des paramètres de configuration

Ajoutons les paramètres de configuration du connecteur Kafka suivants sur le serveur 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

Dans la configuration ci-dessus, les tables Kafka sont chargées à l'aide du programme Kafka-tpch.

Démarrez Presto CLI

Démarrez Presto CLI à l'aide de la commande suivante,

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

Ici “tpch" est un schéma pour le connecteur Kafka et vous recevrez une réponse comme suit.

presto:tpch>

Tables de liste

La requête suivante répertorie toutes les tables de “tpch” schéma.

Requete

presto:tpch> show tables;

Résultat

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

Décrire la table des clients

La requête suivante décrit “customer” table.

Requete

presto:tpch> describe customer;

Résultat

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

L'interface JDBC de Presto est utilisée pour accéder à l'application Java.

Conditions préalables

Installez presto-jdbc-0.150.jar

Vous pouvez télécharger le fichier JDBC jar en visitant le lien suivant,

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

Une fois le fichier jar téléchargé, ajoutez-le au chemin de classe de votre application Java.

Créer une application simple

Créons une application Java simple en utilisant l'interface JDBC.

Codage - 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(); 
      } 
   } 
}

Enregistrez le fichier et quittez l'application. Maintenant, démarrez le serveur Presto dans un terminal et ouvrez un nouveau terminal pour compiler et exécuter le résultat. Voici les étapes -

Compilation

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

Exécution

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

Production

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

Créez un projet Maven pour développer la fonction personnalisée Presto.

SimpleFunctionsFactory.java

Créez la classe SimpleFunctionsFactory pour implémenter l'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

Créez une classe SimpleFunctionsPlugin pour implémenter l'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(); 
   } 
}

Ajouter un fichier de ressources

Créez un fichier de ressources spécifié dans le package d'implémentation.

(com.tutorialspoint.simple.functions.SimpleFunctionsPlugin)

Maintenant, déplacez-vous vers l'emplacement du fichier de ressources @ / chemin / vers / ressource /

Puis ajoutez les modifications,

com.facebook.presto.spi.Plugin

pom.xml

Ajoutez les dépendances suivantes au fichier 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

Créez une classe SimpleFunctions à l'aide des attributs 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; 
   } 
}

Une fois l'application créée, compilez et exécutez l'application. Il produira le fichier JAR. Copiez le fichier et déplacez le fichier JAR dans le répertoire du plugin du serveur Presto cible.

Compilation

mvn compile

Exécution

mvn package

Maintenant, redémarrez le serveur Presto et connectez le client Presto. Exécutez ensuite l'application de fonction personnalisée comme expliqué ci-dessous,

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

Requete

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

Résultat

_col0  
------- 
  20