DEV Community: Saurabh Mahawar

How to Build Presto from Source - OSS Contribution Guide (Step by Step Tutorial)

Saurabh Mahawar — Wed, 14 Jan 2026 10:10:00 +0000

This step-by-step tutorial is designed specifically for beginners and first-time contributors who want to build Presto from source, run the Presto server locally, understand the codebase, and successfully submit their first pull request. By the end of this guide, you will have a fully working local Presto setup and a clear understanding of the complete contribution workflow, from Git setup to PR merge.

Prerequisites

Requirement	Details
Operating System	macOS or Linux (Windows via WSL2)
Java	Java 17 (64-bit) - OpenJDK or Oracle JDK
Python	Python 2.4+ (for launcher scripts), Not Required for Development
Git	Latest version
RAM	Minimum 8GB (16GB recommended)
Disk Space	At least 10GB free

[Tip]
IntelliJ IDEA is recommended for Presto development.

Knowledge Prerequisites

Java Programming Knowledge.
Familiarity with command-line tools
Git & Version Control Basics.
Maven Build Tool.
SQL & Distributed Systems knowledge (helpful but not required).

Required Accounts

GitHub Account
Slack Account (To Join Presto Slack Community, ask in #general or #dev for any help)

Configuring Git

If you are a macOS user, use the pre-installed Git . But, if you are using Linux or Windows, download the latest version of Git from here.

Open the terminal and run the below command.

git --version

Configure Git with your name and email.

Set your name

git config --global user.name "Your Name"

Set your email

git config --global user.email "example@gmail.com"

Installing Java Development Kit (JDK)

Download and Install Java 17 (either OpenJDK or Oracle JDK).
Download .dmg file (if you are on macOS), download link.
Set JAVA_HOME (add to ~/.zshrc or ~/.bash_profile).

Verify JDK Installation

java -version

Forking and Cloning the Repository

Forking The Repository

Navigate to the Presto GitHub repository
Click the "Fork" button in the top-right corner
Create a copy of the Presto repository under your GitHub account.

Cloning Your Forked Repository
Navigate to the directory where you want to store the project on your local machine.

cd ~/ Desktop (or your preferred Directory)

Clone the project

git clone https://github.com/YOUR_USERNAME/presto.git

Navigate to the directory

cd ~/ presto

Verify the cloned repository.

ls -la

Understanding the Presto Project Structure (Codebase)

Understand the key modules in the Presto codebase:

presto/
├── .github/              # GitHub workflows and templates
├── docker/               # Docker configurations
├── presto-accumulo/      # Accumulo connector
├── presto-analyzer/      # Semantic analysis and query validation
├── presto-base-jdbc/     # Base JDBC connector
├── presto-cli/           # Command-line interface
├── presto-client/        # Client libraries
├── presto-common/        # Common utilities
├── presto-docs/          # Documentation (Sphinx/RST)
├── presto-hive/          # Hive connector
├── presto-main/          # Core engine
├── presto-parser/        # SQL parser
├── presto-server/        # Server packaging
├── presto-spi/           # Service Provider Interface
├── presto-tests/         # Integration tests
├── pom.xml               # Root Maven configuration
├── CONTRIBUTING.md       # Contribution guidelines
└── README.md             # Project overview

File	Purpose
`README.md`	Project overview and build instructions
`CONTRIBUTING.md`	Contribution guidelines
`ARCHITECTURE.md`	Mission and technical architecture
`pom.xml`	Maven project configuration
`CODEOWNERS`	Code ownership and module maintainers

[Info]
Note that each module has its own pom.xml and follows Maven’s standard directory structure.

Setting Up IntelliJ IDEA for Presto

1. Configure Maven:

Go to IntelliJ IDEA → Settings → Build, Execution, Deployment → Build Tools → Maven → Use Maven wrapper
Go to Maven → Runner → Enable Skip Tests → Click Apply → OK

2. Configure JDK

Go to File → Project Structure → Project
Set SDK to Java 17 (or download directly)
Go to Run → Edit Configurations
Set Java 17 as SDK and presto-main as class path.
Add below configurations in VM Options.

-ea  
-XX:+UseG1GC  
-XX:G1HeapRegionSize=32M  
-XX:+UseGCOverheadLimit  
-XX:+ExplicitGCInvokesConcurrent  
-Xmx2G  
-Dconfig=/Users/your-complete-path/presto/presto-main/etc/config.properties  
-Dlog.levels-file=etc/log.properties  
-Djdk.attach.allowAttachSelf=true   
--add-opens=java.base/java.io=ALL-UNNAMED  
--add-opens=java.base/java.lang=ALL-UNNAMED  
--add-opens=java.base/java.lang.ref=ALL-UNNAMED  
--add-opens=java.base/java.lang.reflect=ALL-UNNAMED  
--add-opens=java.base/java.net=ALL-UNNAMED  
--add-opens=java.base/java.nio=ALL-UNNAMED  
--add-opens=java.base/java.security=ALL-UNNAMED  
--add-opens=java.base/javax.security.auth=ALL-UNNAMED  
--add-opens=java.base/javax.security.auth.login=ALL-UNNAMED  
--add-opens=java.base/java.text=ALL-UNNAMED  
--add-opens=java.base/java.util=ALL-UNNAMED  
--add-opens=java.base/java.util.concurrent=ALL-UNNAMED  
--add-opens=java.base/java.util.concurrent.atomic=ALL-UNNAMED  
--add-opens=java.base/java.util.regex=ALL-UNNAMED  
--add-opens=java.base/jdk.internal.loader=ALL-UNNAMED  
--add-opens=java.base/sun.security.action=ALL-UNNAMED  
--add-opens=java.security.jgss/sun.security.krb5=ALL-UNNAMED

Set Main Class to com.facebook.presto.server.PrestoServer
Set Working Directory $MODULE_DIR$
Click on Modify Options and check the options

Click Apply to save the configuration. IntelliJ is now set up and ready for Presto development.

Building Presto from Source

Build Presto from source to verify your environment and test your changes.

Navigate to the directory where presto is cloned.

cd ~/Desktop/presto

Run the following command to build Presto for the first time.

./mvnw clean install -DskipTests

[Info]

mvnw: Runs Maven Wrapper

clean: Removes previous build artifacts

install: Compiles code, packages it, and installs to local Maven repository

DskipTests: Skips running tests (faster for initial build)

[Important]
Skipping tests is acceptable only for initial setup or local exploration.

All PRs must pass tests and should be built without -DskipTests before submission.

Verify the setup and run the Presto server directly from IntelliJ.
Confirm that the Presto server is running on localhost:8080

[Success]
Server is running on localhost:8080

Connect with Presto CLI

Open a new terminal, navigate to the presto-cli directory, and then move into the target directory. Run below command.

cd presto-cli/target

java -jar presto-cli-*-SNAPSHOT-executable.jar \
  --server localhost:8080

Verify that the presto prompt appears.

presto> show catalogs;

[Success]
Connected with Presto CLI

Build Specific Modules

To build only a specific module, run the below command:

cd presto-cli
./mvnw clean install -DskipTests

Setting Up Upstream Remote

Keep your fork synchronized with the main Presto repository.

Add the upstream remote

git remote add upstream https://github.com/prestodb/presto.git

Verify your remote

git remote -v

origin: Your fork on GitHub (where you push changes)
upstream: The main Presto repository (where you pull updates)

[NOTE]
Do not commit changes directly to master. Always create a feature branch.

Making Code Contributions

Syncing Your Fork

Before creating a new branch, ensure your fork is up to date:

#Make sure you're on master
git checkout master 

#Fetch updates from upstream
git fetch upstream 

#Merge upstream changes into your master
git merge upstream/master 

#Push updates to your fork
git push origin master

[Tip]
Sync your fork regularly to avoid merge conflicts.

Find an Issue to Fix

Visit the Presto Issues Page, or
Look for issues that interest you, or
Find an Issue to fix with labels like good first issues, documentation, etc

[Important]
Comment on the issue to let others know you're working on it.

Creating a Feature Branch

Create and switch to a new branch, use descriptive branch names that indicate what you're working on:

git checkout -b feature/meaningful-branch-name

[Example]

feature/add-trim-function

bugfix/fix-null-pointer-in-parser

docs/update-contribution-guide

refactor/simplify-planner-logic

test/add-hive-connector-tests

Verify that you are on the new branch.

git branch

Make Your Changes in the Code
Write or Update Tests
Run Tests Locally

# Run tests for the module you changed
cd presto-main
../mvnw test

# If all pass, run full build
cd ..
./mvnw clean install

Commit your changes

# Stage your changes
git add .

# Commit with proper format
git commit -m "Your Message"

Write clear and descriptive commit messages.

[Example]
Commit Message Format:

<type> [(scope)]: <subject>
[optional body]
[optional footer]

Types:

feat: New feature

fix: Bug fix

docs: Documentation only

refactor: Code refactoring

perf: Performance improvement

test: Adding or modifying tests

build: Build system changes

[ToDo]
Subject Line Rules:

Start with capital letter

Use imperative mood ("Add feature" not "Added feature")

No period at the end

Be concise but descriptive

Limit to 50-72 characters when possible

[Example]

git commit -m "feat(function): Add trim function with custom characters"

git commit -m "fix(parser): Handle null values in WHERE clause"

git commit -m "docs(connector): Update Hive connector configuration guide"

Push to your Fork

git push origin feature/meaningful-branch-name

Create a Pull Request (PR)

Go to your fork on GitHub: https://github.com/YOUR_USERNAME/presto
Click "Compare & pull request"
Set: Base repo: prestodb/presto, Base branch: master, Head repo: your fork, Compare branch: your feature branch
Fill out PR Template.

Sign the CLA

[Important]
On your first PR, the CLA bot will comment asking you to sign the Contributor License Agreement:

Click the link provided by the bot

Sign the CLA electronically

The bot will update your PR status

[Success]
You have successfully contributed to Presto Open Source

After Your PR is Merged

Congratulations! You are now a contributor to the Presto project.

[Important Links]
Presto Website: https://prestodb.io
Join Slack: https://communityinviter.com/apps/prestodb/prestodb

prestodb / presto

The official home of the Presto distributed SQL query engine for big data

Presto

Presto is a distributed SQL query engine for big data.

See the Presto installation documentation for deployment instructions.

See the Presto documentation for general documentation.

Mission and Architecture

See PrestoDB: Mission and Architecture.

Requirements

Mac OS X or Linux
Java 17 64-bit. Both Oracle JDK and OpenJDK are supported.
Maven 3.6.3+ (for building)
Python 2.4+ (for running with the launcher script)

Building Presto

Overview (Java)

Presto is a standard Maven project. Simply run the following command from the project root directory:

./mvnw clean install

On the first build, Maven will download all the dependencies from the internet and cache them in the local repository (~/.m2/repository), which can take a considerable amount of time. Subsequent builds will be faster.

When building multiple Presto projects locally, each project may write updates to the user's global M2 cache, which could cause build issues. You can configure your local .mvn/maven.config…

View on GitHub

Get Started with Fastest SQL Query Engine - Presto C++ (Prestissimo): Beginner Friendly Setup Guide with Docker.

Saurabh Mahawar — Mon, 29 Sep 2025 16:48:29 +0000

This step-by-step tutorial shows you how to install and run a PrestoDB Java Coordinator with a Prestissimo (C++) Worker using Docker. This setup uses Meta's high-performance Velox engine for worker-side query execution.

We'll create a lightweight Presto cluster, run a test query with the built-in TPCH connector.

Introducing Prestissimo (Presto C++ Worker)

Prestissimo is the C++ native implementation of the Presto Worker, designed as a drop-in replacement for the traditional Java worker. It is built using Velox, a high-performance open-source C++ database acceleration library created by Meta.

The shift to a C++ execution engine is a major performance innovation for Presto, offering several significant advantages for data lake analytics:

Massive Performance Boost: Prestissimo leverages native C++ execution, vectorization, and SIMD (Single Instruction, Multiple Data) instructions, which can dramatically increase CPU efficiency and reduce query latency, with production results showing fleet sizes shrinking to nearly a third.
Eliminates Java GC Issues: By moving the execution engine out of the JVM, it removes the unpredictable performance spikes and pauses associated with Java Garbage Collection (GC), leading to more consistent and stable query times.
Explicit Memory Control: The Velox memory management framework provides explicit memory accounting and arbitration, offering finer control over resource consumption than the JVM.

Prerequisites ✅

Docker installed (I am using OrbStack).
Basic familiarity with the Terminal and shell commands.

Directory-Structure 🗃️

Let's Get Started! 🛠️

Step 1 - Create a Working Directory

Create a clean directory to hold all your configuration files and the docker-compose.yml.

mkdir -p ~/presto-lab
cd ~/presto-lab

Step 2 - Configure the Presto Java Coordinator

The Coordinator requires configuration for its role, the discovery service, and a catalog to query.

Create Directory:

mkdir -p coordinator/etc/catalog

Create coordinator/etc/config.properties:This enables the coordinator and discovery server, and sets the port.

# coordinator/etc/config.properties
coordinator=true
node-scheduler.include-coordinator=true
http-server.http.port=8080
discovery-server.enabled=true
discovery.uri=http://localhost:8080

coordinator=true: Enables coordinator mode.
discovery-server.enabled=true: Coordinator also hosts the worker discovery service.

Create coordinator/etc/jvm.config: Standard Java 17 flags for Presto.

# coordinator/etc/jvm.config
-server
-Xmx1G
-XX:+UseG1GC
-XX:G1HeapRegionSize=32M
-XX:+UseGCOverheadLimit
-XX:+ExplicitGCInvokesConcurrent
-XX:+HeapDumpOnOutOfMemoryError
-XX:+ExitOnOutOfMemoryError
-Djdk.attach.allowAttachSelf=true
--add-opens=java.base/java.io=ALL-UNNAMED
--add-opens=java.base/java.lang=ALL-UNNAMED
--add-opens=java.base/java.lang.ref=ALL-UNNAMED
--add-opens=java.base/java.lang.reflect=ALL-UNNAMED
--add-opens=java.base/java.net=ALL-UNNAMED
--add-opens=java.base/java.nio=ALL-UNNAMED
--add-opens=java.base/java.security=ALL-UNNAMED
--add-opens=java.base/javax.security.auth=ALL-UNNAMED
--add-opens=java.base/javax.security.auth.login=ALL-UNNAMED
--add-opens=java.base/java.text=ALL-UNNAMED
--add-opens=java.base/java.util=ALL-UNNAMED
--add-opens=java.base/java.util.concurrent=ALL-UNNAMED
--add-opens=java.base/java.util.concurrent.atomic=ALL-UNNAMED
--add-opens=java.base/java.util.regex=ALL-UNNAMED
--add-opens=java.base/jdk.internal.loader=ALL-UNNAMED
--add-opens=java.base/sun.security.action=ALL-UNNAMED
--add-opens=java.security.jgss/sun.security.krb5=ALL-UNNAMED

Create coordinator/etc/node.properties: Sets the node environment and data directory.

# coordinator/etc/node.properties
node.id=${ENV:HOSTNAME}
node.environment=test
node.data-dir=/var/lib/presto/data

Add TPCH Catalog coordinator/etc/catalog/tpch.properties: The TPCH connector allows you to run test queries against an in-memory dataset.

# coordinator/etc/catalog/tpch.properties
connector.name=tpch

Step 3 - Configure the Prestissimo (C++) Worker

The Worker needs to know where the Coordinator/Discovery service is and how to identify itself within the network.

Create Directory

mkdir -p worker-1/etc/catalog

Create worker-1/etc/config.properties: This configuration points the worker to the discovery service.

# worker-1/etc/config.properties
discovery.uri=http://coordinator:8080
presto.version=0.288-15f14bb
http-server.http.port=7777
shutdown-onset-sec=1
runtime-metrics-collection-enabled=true

discovery.uri=http://coordinator:8080: Uses the coordinator service name (defined in docker-compose) for in-network communication.

Create worker-1/etc/node.properties: Defines the worker's internal address for network registration.

# worker-1/etc/node.properties
node.environment=test
node.internal-address=worker-1
node.location=docker
node.id=worker-1

node.internal-address=worker-1: Matches the service name for reliable registration.

Add TPCH Catalog worker-1/etc/catalog/tpch.properties: The worker needs the catalog definition to execute the query stages.

# worker-1/etc/catalog/tpch.properties
connector.name=tpch

Repeat the Step 3 to add more workers

Step 4 - Create docker-compose.yml

This file orchestrates both the Java Coordinator and the C++ Worker containers. Create the file docker-compose.yml in your ~/presto-lab directory:

# docker-compose.yml
services:
  coordinator:
    image: public.ecr.aws/oss-presto/presto:latest
    platform: linux/amd64
    container_name: presto-coordinator
    hostname: coordinator
    ports:
      - "8080:8080"
    volumes:
      - ./coordinator/etc:/opt/presto-server/etc:ro
    restart: unless-stopped

  worker-1:
    image: public.ecr.aws/oss-presto/presto-native:latest
    platform: linux/amd64
    container_name: prestissimo-worker-1
    hostname: worker-1
    depends_on:
      - coordinator
    volumes:
      - ./worker-1/etc:/opt/presto-server/etc:ro
    restart: unless-stopped

  worker-2:
    image: public.ecr.aws/oss-presto/presto-native:latest
    platform: linux/amd64
    container_name: prestissimo-worker-2
    hostname: worker-2
    depends_on:
      - coordinator
    volumes:
      - ./worker-2/etc:/opt/presto-server/etc:ro
    restart: unless-stopped

coordinator uses the standard Java Presto image (presto:latest).
worker-1 & worker-2 uses the Prestissimo (C++ Native) image (presto-native:latest).
platform: linux/amd64 is crucial for Apple Silicon Mac users.
volumes mount your local configuration directories (etc) into the container's expected path (/opt/presto-server/etc).

Step 5 - Start the Cluster and Verify

docker compose up -d

Verify: Open the Presto Web UI at http://localhost:8080. You should see the UI, with 3 Active Workers (1 Coordinator + 2 Workers).

To check detailed status and metadata about every node (Coordinator and Workers). Run below query.

select * from system.runtime.nodes;

Follow Presto at Official Website, Linkedin, Youtube, and Join Slack channel to interact with the community.

Build with PrestoDB: Community Workshop + In-Person Meetup

Saurabh Mahawar — Sat, 28 Jun 2025 15:59:05 +0000

Click Here to Save your Spot

Join In-Person Community Meetup @Bengaluru, India

Saurabh Mahawar — Tue, 24 Jun 2025 18:04:18 +0000

🏷 Event Name: From Data to Decisions – Accelerating Real-Time AI Outcomes
📅 Date: Saturday, July 19, 2025
🕙 Time: 10:00 AM – 1:00 PM
📍 Venue: Cloudera Office, Bengaluru
🔗 RSVP Link: Click Here

Dear Developers, we are happy to invite you to a special in-person event hosted by IBM and Cloudera, bringing together data leaders, AI practitioners, and technology innovators to explore how enterprises can unlock real-time insights and accelerate AI outcomes at scale.

💡 What to Expect:

Expert insights from IBM and Cloudera on modern data architectures
Real-world use cases of AI-driven decision-making.
Networking & Q/A with data professionals, engineers, and thought leaders
Also, some cool swags and delicious lunch.

Whether you’re a data engineer, AI/ML developer, data architect /analyst/engineer/scientist, or business leader exploring the next wave of Data & AI transformation, this meetup is for you.

Spaces are limited! Reserve your spot today and be part of the conversation shaping the future of real-time AI.

Looking forward to meet you.. 👋👋

Setting Up Presto with Apache Superset using Docker 🐳 : Hands-On Guide

Saurabh Mahawar — Mon, 02 Jun 2025 08:32:19 +0000

In previous articles, we explored how to download and install PrestoDB locally on your machine. In this guide, we take it a step further: you'll learn how to set up and run a single-node Presto cluster using Docker, and connect it to Apache Superset. We'll walk through querying data from multiple sources like MySQL and MongoDB via PrestoDB. Whether you're a developer, data engineer, or BI enthusiast, this step-by-step tutorial will help you build a modern analytics stack with open-source tools and Docker.

Pre-Requisites:

Docker Application (I am using OrbStack).
Knowledge of Basic Docker Commands.

Step -1: Project Structure:

Step -2: Setting Up Docker Compose:

version: "3.8"

services:
  superset:
    image: apache/superset:latest
    container_name: superset
    ports:
      - "8088:8088"
    environment:
      SUPERSET_SECRET_KEY: 'supersecretkey'
      PYTHONUNBUFFERED: 1
    depends_on:
      - db
    volumes:
      - superset_home:/app/superset_home
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8088/health"]
      interval: 30s
      timeout: 10s
      retries: 5
    command: >
      /bin/bash -c "
      sleep 10 &&
      superset db upgrade &&
      superset fab create-admin --username admin --firstname Admin --lastname User --email admin@superset.com --password admin &&
      superset init &&
      superset run -h 0.0.0.0 -p 8088
      "

  db:
    image: postgres:15
    container_name: superset_db
    environment:
      POSTGRES_DB: superset
      POSTGRES_USER: superset
      POSTGRES_PASSWORD: superset
    volumes:
      - db_data:/var/lib/postgresql/data

  mysql:
    image: mysql:latest
    container_name: mysql
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: testdb
    ports:
      - "3307:3306"
    volumes:
      - mysql_data:/var/lib/mysql

  mongo:
    image: mongo:latest
    container_name: mongodb
    ports:
      - "27018:27017"
    volumes:
      - mongo_data:/data/db

  presto:
    image: prestodb/presto:latest
    container_name: presto
    ports:
      - "8081:8080"
    volumes:
      - ./presto/etc/catalog/mongodb.properties:/opt/presto-server/etc/catalog/mongodb.properties
      - ./presto/etc/catalog/mysql.properties:/opt/presto-server/etc/catalog/mysql.properties
    depends_on:
      - mysql
      - mongo

volumes:
  superset_home:
  db_data:
  mysql_data:
  mongo_data:

Step -3: Creating Presto Catalog Files:

mysql.properties (To connect MySQL Database)

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

mongodb.properties (To connect MongoDB Database)

connector.name=mongodb
mongodb.seeds=mongodb:27017

Step -4: Start all the Services:

Go to terminal and navigate to the docker-compose.yml file directory.

Hit the below command. (It will automatically start all the services, just wait for 3-5 mins, as docker will pull all the images).

docker-compose up -d

Once all the images are pulled, hit the below command to check the status of all containers.

docker ps

You will see an output like snapshot shared above. Now, let's confirm that PrestoDB and Apache Superset are running on their respective ports or not.
Open browser and check Apache Superset is listening on port 8088 (http://localhost:8088/) and Presto on port 8081 (http://localhost:8081/).

Step -5: Connecting PrestoDB as a database to Apache Superset:

Superset doesn't ship Presto driver by default. So, as a next step we need to install it manually. Hit the below command to enter inside superset docker container.

docker exec -it superset bash

As soon as you hit this command, you will be inside superset docker container.
We need to install pyhive[presto], this is a important Python package to connect PrestoDB with Superset. Hit the below command.

pip install "pyhive[presto]"

Once Installation is complete, exit the Superset container using exit command and restart Superset container.

docker restart superset

Open Superset on browser: localhost:8088 and enter username and password.

Username:admin
Password:admin

Navigate to Settings -> Database Connections -> Database.

Click on CONNECT once you see "Connection looks good".
Congratulations, everything is running smoothly and Presto has connected with Apache Superset.

Step -6: Let's run a SQL Query also verify MySQL and MongoDB should visible as Catalogs:

Conclusion:

Follow Presto at Official Website, Linkedin, Youtube, and Join Slack channel to interact with the community.

📊 Visualise Presto Queries with Apache Zeppelin: A Hands-On Guide

Saurabh Mahawar — Tue, 13 May 2025 05:41:06 +0000

In the previous article, we explored the installation of Presto. Building on that foundation, it's time to take your data exploration one step further by integrating Presto with Apache Zeppelin, a powerful web-based notebook that allows interactive data analytics.

Zeppelin provides an easy-to-use interface where you can write and execute SQL queries directly on Presto and visualise your data seamlessly. Whether you're a data engineer, data scientist, or developer, connecting Presto with Zeppelin opens the door to interactive data exploration, and stunning visualization's.

Pre-Requisites 🎯

Open JDK or Oracle JDK {1.8 (151+)}
OS (Mac/ Ubuntu)

I am using Apache Zeppelin version 0.11.2, because its compatible with JDK 1.8, you can get latest version if you have JDK 11 installed.

Step - 1: Install Apache Zeppelin 📥

Open below link in any browser (Chrome/ Safari/ Firefox). It will redirect to official Apache Zeppelin download page.

https://zeppelin.apache.org/download.html

Create a directory at Desktop or any preferred location in your system and name it Zeppelin (or whatever you like). Move the downloaded package to the Zeppelin directory.
Open terminal/command line interface and navigate to your Zeppelin directory and run below command.

tar -xvzf zeppelin-*.tgz (replace * with your downloaded version)

It will create a directory like this: zeppelin-0.11.2-bin-all

Step -2 : Configure Apache Zeppelin ⚙️ 🔧

Apache Zeppelin uses default port 8080 and uses Hadoop or Spark at the time of start, so we have to configure it to run Zeppelin smoothly.

We can't use port 8080 for Zeppelin because its already in use by Presto server, so we will configure it for some other port, for example (8888).

Also, we are not using Hadoop or Spark at the moment, so we will disable it as well,(Optional if you are using Hadoop or Spark).

Navigate to conf directory inside zeppelin-0.11.2-bin-all. Inside conf directory, two files will be available named as zeppelin-env.sh.template and zeppelin-site.xml.template
Create a copy of both files and rename it to zeppelin-env.sh and zeppelin-site.xml respectively.
Open zeppelin-env.sh in any text editor or code editor (I prefer Visual Studio Code) and add below code in the last line. Save and close the file, after adding the code.

export USE_HADOOP= false

📌 This will disable the Hadoop configuration for Apache Zeppelin

Now open zeppelin-site.xml file and look for below code.

<property>
  <name>zeppelin.server.port</name>
  <value>8080</value>
  <description>Server port.</description>
</property>

Replace the port 8080 with any port which is available, in my case I have added 8888, save and close the file, after making changes in configuration.

<property>
  <name>zeppelin.server.port</name>
  <value>8888</value>
  <description>Server port.</description>
</property>

Now, we are all set 😎, Let's Go 🚀

Step - 3: Start Apache Zeppelin 🏁 🟢

Open terminal/command line interface and navigate to zeppelin-0.11.2-bin-all directory.
Run below command to start Apache Zeppelin.

bin/zeppelin-daemon.sh start

As soon as you will hit the command, Apache Zeppelin will be started and it will be accessible on localhost:8888

To check the status of Apache Zeppelin 🔎

bin/zeppelin-daemon.sh status

To stop the Apache Zeppelin 🔴

bin/zeppelin-daemon.sh stop

Step - 4: Connecting Apache Zeppelin to Presto 🔗

To connect Zeppelin to Presto, we need Presto JDBC driver.
Open below link in any browser (Chrome/ Safari/ Firefox) and download the Presto JDBC driver.

https://prestodb.io/getting-started/

Once you click download, presto-jdbc-0.291.jar file will be downloaded.
You need to move this jar file to the below directory.

Desktop/ Zeppelin/ zeppelin-0.11.2-bin-all/ interpreter/ jdbc/

Restart Zeppelin to load the driver 🔄

bin/zeppelin-daemon.sh restart

Step - 5 : Create Presto Interpreter in Zeppelin 🔀

Open browser and go to localhost:8888
Click on Interpreter tab at the top right of the page.

Click on + Create in the top right corner

Fill the following details under Create new Interpreter

📌 Interpreter Name: presto
📌 Interpreter group: jdbc

Let's configure JDBC properties for Presto

📌 default.url -> jdbc:presto://localhost:8080/mysql/default
📌 default.user -> presto
📌 default.driver -> com.facebook.presto.jdbc.PrestoDriver

Save the configuration and we are good to go.
Restart Apache Zeppelin to reload the interpreter 🔄

bin/zeppelin-daemon.sh restart

Step - 6: Now It's showtime, Run SQL Queries 🔥

Click on Notebook from Zeppelin dashboard and Create new Note.

Name the note anything you like (Presto Query Engine).
Select presto from the drop down list for Default Interpreter.

Add the following line to the first paragraph of the notebook to establish the connection.

%presto

Run Basic SQL Queries to check everything is running smoothly. For Example:

%presto
Show CATALOGS;

Follow Presto at Official Website, Linkedin, Youtube, and Join Slack channel to interact with the community.

🚀 Setting Up Presto : A Step by Step Installation Guide to Run SQL Queries.

Saurabh Mahawar — Thu, 01 May 2025 15:03:05 +0000

In previous articles, we explored the fundamentals of Presto as a powerful open-source SQL query engine and the modern data storage paradigms of data warehouses and data lakes. Now it's time to roll up our sleeves and get our hands dirty with a practical implementation.

In this guide, I'll walk you through installing Presto and show how to run queries with ease.

Pre-Requisites

Before getting started, ensure that the following are installed:

Operating System: macOS (Intel or Apple Silicon), Linux, or Windows.
Java Development Kit (JDK): Java 17 is now required for newer Presto versions. (Java 8 is no longer sufficient). (Run java -version to confirm).
Python: Version 2.7 or 3.x (Presto’s launcher uses Python). (Run python3 --version to confirm).
RAM: Minimum 4GB available (8GB+ recommended).

Download and Extract

Open terminal/command line interface and run below command’s.

# 1. Download the tarball
wget https://repo1.maven.org/maven2/com/facebook/presto/presto-server/0.296/presto-server-0.296.tar.gz

# 2. Extract it
tar -xvzf presto-server-0.296.tar.gz

# 3. Move it to your Desktop or your preferred directory
mv presto-server-0.296 ~/Desktop/presto-server
cd ~/Desktop/presto-server

Verify that the resulting directory structure matches the example below:

Configure the Server

Inside presto-server–*, create the etc configuration directory.

mkdir etc

Create the following four files inside the etc directory: config.properties, jvm.config, log.properties, and node.properties.

Apply the following configurations to the node.properties file. (This identifies your machine).

node.environment=production
node.id=ffffffff-ffff-ffff-ffff-ffffffffffff
node.data-dir=/path-to-your-presto-server/data -----> Set this path to your presto server directory location

Apply the following configurations to the jvm.config file. (This tunes the Java engine. Use this exact config to support Java 17).

-server
-Xmx2G
-XX:+UseG1GC
-XX:G1HeapRegionSize=32M
-XX:+UseGCOverheadLimit
-XX:+ExplicitGCInvokesConcurrent
-XX:+HeapDumpOnOutOfMemoryError
-XX:OnOutOfMemoryError=kill -9 %p
--add-opens=java.base/java.io=ALL-UNNAMED
--add-opens=java.base/java.lang=ALL-UNNAMED
--add-opens=java.base/java.lang.reflect=ALL-UNNAMED
--add-opens=java.base/java.lang.invoke=ALL-UNNAMED
--add-opens=java.base/java.util=ALL-UNNAMED
--add-opens=java.base/java.util.concurrent=ALL-UNNAMED
--add-opens=java.base/java.util.concurrent.atomic=ALL-UNNAMED
--add-opens=java.base/java.nio=ALL-UNNAMED
--add-opens=java.base/sun.nio.ch=ALL-UNNAMED
-Djdk.attach.allowAttachSelf=true

Apply the following configurations to the config.properties file. (This sets up your node as both a Coordinator and a Worker).

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

query.max-memory (1.5GB) must be smaller than the JVM Heap (2GB).

Apply the following configurations to the log.properties file. (This sets your default logging level).

com.facebook.presto=INFO

Add Data Connectors

Create the catalog folder inside etc directory:

mkdir etc/catalog

Create a file named etc/catalog/tpch.properties and apply below configuration:

connector.name=tpch

Start the Server

Navigate to the presto-server-* directory and run command:

bin/launcher start

Wait 10 seconds, then check the status:

bin/launcher status

Access the Presto UI at http://localhost:8080 via your web browser.

Run Your First Query through Presto CLI

Download the CLI from here and move the jar file to presto-server-* directory with below command:

mv ~/Downloads/presto-cli-0.296-executable.jar ./presto

Make it executable:

chmod +x presto

Connect to your local cluster:

./presto --server localhost:8080 --catalog tpch --schema tiny

Once you see the presto:tiny> prompt, you can type your SQL:

SHOW TABLES;

Run a standard TPC-H aggregation query

SELECT returnflag, linestatus, sum(quantity) as sum_qty, count(*) as count_order FROM lineitem GROUP BY returnflag, linestatus;

To stop the server cleanly:

bin/launcher stop

Troubleshooting Common Issues

If the server fails to launch, investigate these three common configuration pitfalls:

Port 8080 already in use

The Error: java.net.BindException: Address already in use. Another app (often another web server or Jenkins) is using port 8080.

The Fix: Kill the process using it: lsof -i :8080 then kill -9 . Change Presto’s port in etc/config.properties to 8081.

Java version not supported

The Error: Presto requires Java 17+ (found 1.8.0_xxx). You are running an old Java version.

The Fix: Run java -version to check. If you have valid Java 17 installed but it’s not default, point to it explicitly in your startup command: JAVA_HOME=/path/to/java17 bin/launcher start

Server Starts but Dies Immediately

The Error: Launcher says “Started” but status says “Not running”. This is usually a configuration typo or memory issue.

The Fix: Check the detailed logs: cat data/var/log/server.log. Ensure query.max-memory in config.properties is less than -Xmx in jvm.config.

In the next article, we will see how to install Apache Zeppelin and connect it with Presto.

Follow Presto at Official Website, Linkedin, Youtube, and Join Slack channel to interact with the community.

Data Warehouses and Data Lakes: Understanding Modern Data Storage Paradigms 📦

Saurabh Mahawar — Fri, 25 Apr 2025 16:20:42 +0000

To harness the power of data for decision-making, businesses rely on data management architectures like data warehouses and data lakes. While both serve as data repositories, they cater to different use cases, offering unique advantages and challenges. In this evolving landscape, Presto has emerged as a powerful query engine that bridges the gap between data warehouses and data lakes, enabling fast, distributed SQL queries across disparate data sources.

What is a Data Warehouse? (🏛️ -> 🛢️+🛢️+🛢️)
A data warehouse is a structured repository designed for analytical processing and reporting. It integrates data from multiple sources, transforms it into a consistent format, and stores it in a structured manner using predefined schemas. Data warehouses are optimized for fast query performance and are widely used for business intelligence (BI), reporting, and analytics.

Key Characteristics of Data Warehouses:

Structured Data Storage: Data is cleaned, processed, and stored in structured formats, making it easy to query.
Schema-on-Write: Data must conform to a predefined schema before being stored.
Optimized for Analytical Queries: Supports complex SQL queries and aggregations for reporting.
Historical Data Analysis: Designed to store and analyze historical data trends over time.
Examples: Amazon Redshift, Google BigQuery, Snowflake, etc.
Supported Data Types: Structured data such as relational databases and transactional data.

What is a Data Lake? (🏛️ -> 🔊+🎬+🗂️+📊+📈)
A data lake is a centralized repository that stores vast amounts of raw, structured, semi-structured, and unstructured data. Unlike data warehouses, data lakes do not enforce a predefined schema, allowing organizations to store data in its native format and process it when needed.

Data Sources 📚: Where your data comes from (databases, files, etc.).
Ingestion 📥: Bringing data into the lake.
Raw Data Lake 🏞️: Stores data in its original form.
Transformation 🛠️: Cleaning and preparing data.
Curated Data Lake 📊: Organized data ready for analysis.
Analysis & ML 📈🧠: Using the data for insights and predictions.
Data Catalog 📝: Keeps track of your data.
Governance 🛡️: Ensures data quality and security.

Key Characteristics of Data Lakes:

Schema-on-Read: Data is stored in raw form and structured at the time of analysis.
Supports Diverse Data Types: Can store structured, semi-structured, and unstructured data such as logs, multimedia files, and sensor data.
Highly Scalable and Cost-Effective: Built on cloud-based storage systems that allow massive scalability.
Flexible Analytics: Supports machine learning (ML), big data analytics, and real-time processing.
Examples: Amazon S3 (with AWS Lake Formation), Azure Data Lake, Google Cloud Storage, Apache Hadoop.
Supported Data Types: Structured (relational databases), semi-structured (JSON, XML, CSV), and unstructured (images, videos, IoT sensor data, social media feeds, logs).

Note: Presto has the ability (💪) to query data from both warehouses and lakes without data movement or duplication.

Follow Presto at Official Website, Linkedin, Youtube, and Slack channel to join the community.

Introduction to Presto: Open Source SQL Query Engine that's changing Big Data Analytics

Saurabh Mahawar — Fri, 25 Apr 2025 11:38:37 +0000

In today's data-driven world, organizations face a constant challenge: how to analyse massive datasets quickly and efficiently without moving data between disparate systems. Presto, an open-source distributed SQL query engine that's revolutionizing how we approach big data analytics.

What is Presto?
Presto is an open-source distributed SQL query engine designed for fast interactive analysis of data at any scale. Unlike traditional database systems that require data to be loaded into their proprietary storage format, Presto can query data directly where it lives – be it Hadoop, AWS S3, Google Cloud Storage, Relational Databases, NoSQL systems, or even custom data sources.

Presto Architecture allows you:

Query data across multiple sources without ETL (Extract, Transform & Load).
Process petabytes of data with sub-second query response times.
Use familiar ANSI SQL syntax for complex analytics.
Scale resources independently of your data volume.

The Origin Story: From Facebook to Global Adoption
Presto was born in 2012 at Facebook (now Meta) when engineers faced a challenge: Facebook's data analysts were waiting hours for their Hive queries to complete, severely limiting their productivity.

The team set out to build a new query engine that could provide interactive query speeds on Facebook's massive 300PB data warehouse. Within a few months, they had a prototype that was 10x faster than Hive for many workloads, and by 2013, Facebook open-sourced Presto to the world.

Since then, Presto has been adopted by technology giants like Uber, Netflix, Twitter, and Airbnb, as well as countless enterprises across industries.

Coordinator Node (👨💼)
The coordinator is the brain of the operation:

Accepts SQL queries from clients
Parses and analyzes queries
Creates and optimizes query execution plans
Distributes work to worker nodes
Tracks progress and returns results to clients

Worker Nodes (👷,👷,👷)
Workers are the computational workhorses:

Execute tasks assigned by the coordinator
Read data from source systems through connectors
Process data in parallel
Exchange intermediate results with other workers
Return final results to the coordinator

Connectors (🔌)
Connectors are Presto's interfaces to data sources:

Abstract away the details of different storage systems
Handle data location, format, and access methods
Translate between Presto's internal representation and source data formats
Enable seamless querying across disparate systems

Real-World Use Cases

Data Lake Analytics
Federated Queries Across Systems
Interactive BI & Dash-boarding (Real Time Analytics)

Note: Presto is not a Database (⛔) and it doesn't replace databases.

Follow Presto at Official Website, Linkedin, Youtube, and Slack channel to join the community.

DEV Community: Saurabh Mahawar

How to Build Presto from Source - OSS Contribution Guide (Step by Step Tutorial)

Prerequisites

Knowledge Prerequisites

Required Accounts

Configuring Git

Installing Java Development Kit (JDK)

Forking and Cloning the Repository

Forking The Repository

Cloning Your Forked Repository

Understanding the Presto Project Structure (Codebase)

Setting Up IntelliJ IDEA for Presto

1. Configure Maven:

2. Configure JDK

Building Presto from Source

Connect with Presto CLI

Build Specific Modules

Setting Up Upstream Remote

Making Code Contributions

Syncing Your Fork

Find an Issue to Fix

Creating a Feature Branch

After Your PR is Merged

prestodb / presto

The official home of the Presto distributed SQL query engine for big data

Presto

Mission and Architecture

Requirements

Building Presto

Overview (Java)

Get Started with Fastest SQL Query Engine - Presto C++ (Prestissimo): Beginner Friendly Setup Guide with Docker.

Introducing Prestissimo (Presto C++ Worker)

Prerequisites ✅

Directory-Structure 🗃️

Let's Get Started! 🛠️

Build with PrestoDB: Community Workshop + In-Person Meetup

Join In-Person Community Meetup @Bengaluru, India

💡 What to Expect:

Setting Up Presto with Apache Superset using Docker 🐳 : Hands-On Guide

📊 Visualise Presto Queries with Apache Zeppelin: A Hands-On Guide

🚀 Setting Up Presto : A Step by Step Installation Guide to Run SQL Queries.

Pre-Requisites

Download and Extract

Configure the Server

Add Data Connectors

Start the Server

Run Your First Query through Presto CLI

Troubleshooting Common Issues

Data Warehouses and Data Lakes: Understanding Modern Data Storage Paradigms 📦

Introduction to Presto: Open Source SQL Query Engine that's changing Big Data Analytics