### Install and Setup Apache Pinot Go Client

Source: https://docs.pinot.apache.org/release-0.11.0/users/clients/golang

Provides shell commands to set up a local Apache Pinot quickstart instance, clone the Go client library, and build/run the example application to verify the setup.

```Shell
bin/quick-start-batch.sh
```

```Shell
git clone git@github.com:xiangfu0/pinot-client-go.git
cd pinot-client-go
```

```Shell
go build ./examples/batch-quickstart
./batch-quickstart
```

--------------------------------

### Run Pinot QuickStart Join Example

Source: https://docs.pinot.apache.org/release-0.10.0/basics/getting-started/quick-start

Demonstrates how to set up and run the Pinot QuickStart example for join operations, which involves starting Pinot components, creating tables, ingesting data, and executing sample queries. This can be achieved either via a Docker container or using local launcher scripts.

```docker
docker run \
    -p 9000:9000 \
    apachepinot/pinot:0.9.3 QuickStart \
    -type join
```

```bash
./bin/pinot-admin.sh QuickStart -type join
```

--------------------------------

### Install Apache Pinot Quickstart Batch

Source: https://docs.pinot.apache.org/users/clients/golang

This command initiates the Apache Pinot quickstart setup for batch processing, which is a prerequisite for running the Go client examples locally.

```bash
bin/quick-start-batch.sh
```

--------------------------------

### Run Apache Pinot QuickStart for Streaming with Minion Cleanup

Source: https://docs.pinot.apache.org/release-1.0.0/basics/getting-started/quick-start

This example showcases stream processing in Apache Pinot with continuous segment optimization using Minion tasks (RealtimeToOfflineSegmentsTask and MergeRollupTask). It includes the Pinot Minion component in the setup, creates a `githubEvents` table, and processes a GitHub events stream from Kafka.

```Shell
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type realtime_minion
```

```Shell
./bin/pinot-admin.sh QuickStart -type realtime_minion
```

--------------------------------

### Run Apache Pinot QuickStart for basic streaming

Source: https://docs.pinot.apache.org/release-1.1.0/basics/getting-started/quick-start

Demonstrates basic stream processing with Apache Pinot. This setup starts Apache Kafka, Apache Zookeeper, Pinot Controller, Pinot Broker, and Pinot Server, then creates a 'meetupRsvp' table, launches a 'meetup' stream, and publishes data to a Kafka topic 'meetupRSVPEvents' for Pinot to subscribe to.

```bash
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type stream
```

```bash
./bin/pinot-admin.sh QuickStart -type stream
```

```bash
pinot-admin QuickStart -type stream
```

--------------------------------

### Run Apache Pinot QuickStart for streaming with minion cleanup

Source: https://docs.pinot.apache.org/release-1.1.0/basics/getting-started/quick-start

Demonstrates stream processing in Apache Pinot with RealtimeToOfflineSegmentsTask and MergeRollupTask minion tasks continuously optimizing segments as data gets ingested. This setup starts Apache Kafka, Apache Zookeeper, Pinot Controller, Pinot Broker, Pinot Minion, and Pinot Server, then creates a 'githubEvents' table, launches a GitHub events stream, and publishes data to a Kafka topic 'githubEvents' for Pinot to subscribe to.

```bash
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type realtime_minion
```

```bash
./bin/pinot-admin.sh QuickStart -type realtime_minion
```

```bash
pinot-admin QuickStart -type realtime_minion
```

--------------------------------

### Execute Pinot QuickStart for Join Operations

Source: https://docs.pinot.apache.org/release-0.12.1/basics/getting-started/quick-start

Demonstrates how to run the Apache Pinot QuickStart for join operations using the Lookup UDF. This setup initializes all necessary Pinot components (Zookeeper, Controller, Broker, Server), creates `baseballStats` and `dimBaseballTeams` tables, ingests sample CSV data, and allows for sample query execution.

```Docker
docker run \
    -p 9000:9000 \
    apachepinot/pinot:0.9.3 QuickStart \
    -type join
```

```Bash
./bin/pinot-admin.sh QuickStart -type join
```

--------------------------------

### Build and Run Pinot Go Client Example

Source: https://docs.pinot.apache.org/release-1.2.0/for-users/clients/golang

Builds the batch quickstart example application for the Pinot Go client and then executes it to demonstrate querying a local Pinot instance, verifying the client setup.

```Bash
go build ./examples/batch-quickstart
./batch-quickstart
```

--------------------------------

### Install and Run Pinot Go Client Example

Source: https://docs.pinot.apache.org/release-0.10.0/users/clients/golang

Commands to set up the Apache Pinot batch quickstart, clone the Go client repository, and then build and run the example application to query Pinot locally.

```bash
bin/quick-start-batch.sh
```

```bash
git clone git@github.com:xiangfu0/pinot-client-go.git
cd pinot-client-go
```

```bash
go build ./examples/batch-quickstart
./batch-quickstart
```

--------------------------------

### Run Pinot Join Example QuickStart

Source: https://docs.pinot.apache.org/release-0.11.0/basics/getting-started/quick-start

This example demonstrates how to set up and run a Pinot QuickStart instance configured for join operations using the Lookup UDF. It initializes Zookeeper, Pinot components (Controller, Broker, Server), creates and ingests data for `baseballStats` and `dimBaseballTeams` tables, and prepares the environment for sample queries.

```bash
docker run \
    -p 9000:9000 \
    apachepinot/pinot:0.11.0 QuickStart \
    -type join
```

```bash
./bin/pinot-admin.sh QuickStart -type join
```

--------------------------------

### Install and Run Apache Pinot Go Client Example

Source: https://docs.pinot.apache.org/release-0.9.0/users/clients/golang

Steps to set up the Apache Pinot batch Quickstart locally, clone the Go client library, build, and run its example application to query Pinot.

```bash
bin/quick-start-batch.sh
```

```bash
git clone git@github.com:xiangfu0/pinot-client-go.git
cd pinot-client-go
```

```bash
go build ./examples/batch-quickstart
./batch-quickstart
```

--------------------------------

### Install Pinot Quickstart Batch

Source: https://docs.pinot.apache.org/release-1.3.0/for-users/clients/golang

Executes the Pinot quickstart script to set up a local Pinot instance for batch processing, which is a prerequisite for using the Go client examples.

```Bash
bin/quick-start-batch.sh
```

--------------------------------

### Run Apache Pinot QuickStart for Hybrid Processing

Source: https://docs.pinot.apache.org/release-1.0.0/basics/getting-started/quick-start

This example demonstrates hybrid stream and batch processing in Apache Pinot. It sets up Kafka, Zookeeper, and Pinot components, creates an `airlineStats` table, ingests historical Avro data, streams real-time flight stats via Kafka, and allows for sample queries. This setup showcases Pinot's ability to combine batch and streaming data.

```bash
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type hybrid
```

```bash
./bin/pinot-admin.sh QuickStart -type hybrid
```

--------------------------------

### Setting up Apache Pinot Quickstart and Go Client

Source: https://docs.pinot.apache.org/release-0.12.1/users/clients/golang

This snippet provides shell commands to start a local Apache Pinot batch quickstart instance, clone the Go client library, and build/run its example application. It's a prerequisite for using the Go client.

```Shell
bin/quick-start-batch.sh
```

```Shell
git clone git@github.com:startreedata/pinot-client-go.git
cd pinot-client-go
```

```Shell
go build ./examples/batch-quickstart
./batch-quickstart
```

--------------------------------

### Run Pinot Hybrid QuickStart Example

Source: https://docs.pinot.apache.org/basics/getting-started/quick-start

This example demonstrates how to do hybrid stream and batch processing with Apache Pinot. It sets up Kafka, Zookeeper, and Pinot components, creates an `airlineStats` table, ingests batch data, launches a stream, publishes data to Kafka, and allows sample queries.

```docker
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type hybrid
```

```bash
./bin/pinot-admin.sh QuickStart -type hybrid
```

```bash
pinot-admin QuickStart -type hybrid
```

--------------------------------

### Run Pinot Join QuickStart Example

Source: https://docs.pinot.apache.org/basics/getting-started/quick-start

This example demonstrates how to perform joins in Apache Pinot using the Lookup UDF. It sets up Zookeeper and Pinot components, creates `baseballStats` and `dimBaseballTeams` tables, ingests data into both, and allows sample queries.

```docker
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type join
```

```bash
./bin/pinot-admin.sh QuickStart -type join
```

```bash
pinot-admin QuickStart -type join
```

--------------------------------

### Run Pinot QuickStart for Streaming Processing

Source: https://docs.pinot.apache.org/release-0.11.0/basics/getting-started/quick-start

This example demonstrates how to perform stream processing with Pinot. It starts Apache Kafka and all Pinot components, creates a 'meetupRsvp' table, launches a 'meetup' stream, publishes data to a Kafka topic, and enables sample queries.

```docker
docker run \
    -p 9000:9000 \
    apachepinot/pinot:0.11.0 QuickStart \
    -type stream
```

```bash
./bin/pinot-admin.sh QuickStart -type stream
```

--------------------------------

### Run Apache Pinot QuickStart for streaming JSON data

Source: https://docs.pinot.apache.org/release-1.1.0/basics/getting-started/quick-start

Demonstrates stream processing with JSON documents in Apache Pinot. This setup starts Apache Kafka, Apache Zookeeper, Pinot Controller, Pinot Broker, and Pinot Server, then creates a 'meetupRsvp' table, launches a 'meetup' stream, and publishes data to a Kafka topic 'meetupRSVPEvents' for Pinot to subscribe to.

```bash
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type stream_json_index
```

```bash
./bin/pinot-admin.sh QuickStart -type stream_json_index
```

```bash
pinot-admin QuickStart -type stream_json_index
```

--------------------------------

### Run Pinot QuickStart Join Example

Source: https://docs.pinot.apache.org/release-0.12.0/basics/getting-started/quick-start

This command initiates a Pinot QuickStart environment, pre-configured to demonstrate join operations using the Lookup UDF. It sets up all necessary Pinot components (Zookeeper, Controller, Broker, Server) and ingests sample baseball data into 'baseballStats' and 'dimBaseballTeams' tables, enabling immediate execution of join queries.

```Shell
docker run \
    -p 9000:9000 \
    apachepinot/pinot:0.9.3 QuickStart \
    -type join
```

```Shell
./bin/pinot-admin.sh QuickStart -type join
```

--------------------------------

### Run Apache Pinot QuickStart for Hybrid Stream and Batch Processing

Source: https://docs.pinot.apache.org/release-1.3.0/basics/getting-started/quick-start

This example demonstrates setting up Apache Pinot for hybrid stream and batch processing. It starts Kafka, Zookeeper, and Pinot components, then creates the `airlineStats` table, ingests batch data, and sets up a Kafka stream for real-time data.

```Shell
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type hybrid
```

```Shell
./bin/pinot-admin.sh QuickStart -type hybrid
```

```Shell
pinot-admin QuickStart -type hybrid
```

--------------------------------

### Run Apache Pinot QuickStart for streaming with upsert

Source: https://docs.pinot.apache.org/release-1.1.0/basics/getting-started/quick-start

Demonstrates stream processing with upsert functionality in Apache Pinot. This setup starts Apache Kafka, Apache Zookeeper, Pinot Controller, Pinot Broker, and Pinot Server, then creates a 'meetupRsvp' table, launches a 'meetup' stream, and publishes data to a Kafka topic 'meetupRSVPEvents' for Pinot to subscribe to.

```bash
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type upsert
```

```bash
./bin/pinot-admin.sh QuickStart -type upsert
```

```bash
pinot-admin QuickStart -type upsert
```

--------------------------------

### Run Apache Pinot QuickStart for Basic Streaming

Source: https://docs.pinot.apache.org/release-1.3.0/basics/getting-started/quick-start

Demonstrates basic stream processing with Apache Pinot. This command starts Kafka, Zookeeper, and Pinot components (Controller, Broker, Server), creates a `meetupRsvp` table, launches a `meetup` stream, publishes data to a Kafka topic, and allows sample queries to Pinot.

```bash
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type stream
```

```bash
./bin/pinot-admin.sh QuickStart -type stream
```

```bash
pinot-admin QuickStart -type stream
```

--------------------------------

### Run Apache Pinot QuickStart for Streaming with Minion Cleanup

Source: https://docs.pinot.apache.org/release-0.12.1/basics/getting-started/quick-start

This example showcases stream processing in Apache Pinot with continuous segment optimization using RealtimeToOfflineSegmentsTask and MergeRollupTask minion tasks. It sets up Kafka, Zookeeper, Pinot components (including Minion), creates a `githubEvents` table, launches a GitHub stream, publishes data, and enables sample queries. It uses the `realtime_minion` QuickStart type.

```bash
docker run \
    -p 9000:9000 \
    apachepinot/pinot:0.9.3 QuickStart \
    -type realtime_minion
```

```bash
./bin/pinot-admin.sh QuickStart -type realtime_minion
```

--------------------------------

### Run Apache Pinot QuickStart for Basic Streaming

Source: https://docs.pinot.apache.org/release-1.0.0/basics/getting-started/quick-start

This example demonstrates basic stream processing with Apache Pinot. It sets up the core Pinot components, Kafka, and Zookeeper, then creates a `meetupRsvp` table, launches a `meetup` stream, and publishes data to a Kafka topic for ingestion into Pinot, enabling subsequent querying.

```Shell
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type stream
```

```Shell
./bin/pinot-admin.sh QuickStart -type stream
```

--------------------------------

### Run Apache Pinot QuickStart for Streaming JSON

Source: https://docs.pinot.apache.org/release-0.12.1/basics/getting-started/quick-start

This example demonstrates stream processing of JSON documents in Apache Pinot. It initializes Kafka, Zookeeper, and Pinot components, creates a `meetupRsvp` table, launches a `meetup` stream, publishes data to Kafka, and allows sample queries. It uses the `stream_json_index` QuickStart type.

```bash
docker run \
    -p 9000:9000 \
    apachepinot/pinot:0.9.3 QuickStart \
    -type stream_json_index
```

```bash
./bin/pinot-admin.sh QuickStart -type stream_json_index
```

--------------------------------

### Run Pinot QuickStart for Batch JSON Processing

Source: https://docs.pinot.apache.org/release-0.11.0/basics/getting-started/quick-start

This example demonstrates how to import and query JSON documents in Pinot. It initializes all necessary Pinot components, creates a 'githubEvents' table, ingests data from a JSON file, and allows for sample queries.

```docker
docker run \
    -p 9000:9000 \
    apachepinot/pinot:0.11.0 QuickStart \
    -type batch_json_index
```

```bash
./bin/pinot-admin.sh QuickStart -type batch_json_index
```

--------------------------------

### Execute Pinot Quickstart Python Example

Source: https://docs.pinot.apache.org/release-0.9.0/users/clients/python

Command to run a sample Python script (`pinot-quickstart-batch.py`) that interacts with the Apache Pinot Quickstart instance. This script demonstrates querying data from the quickstart setup.

```bash
python3 examples/pinot-quickstart-batch.py
```

--------------------------------

### Build and Run Pinot Go Client Example

Source: https://docs.pinot.apache.org/release-0.12.0/users/clients/golang

Builds the example application for the Pinot Go client and then executes it. This demonstrates how to use the client to query data from the locally running Pinot Batch Quickstart instance, verifying the setup.

```Shell
go build ./examples/batch-quickstart
./batch-quickstart
```

--------------------------------

### Run Apache Pinot QuickStart for Upsert Streaming

Source: https://docs.pinot.apache.org/release-0.12.1/basics/getting-started/quick-start

This example demonstrates stream processing with upsert functionality in Apache Pinot. It initializes Kafka, Zookeeper, and Pinot components, creates a `meetupRsvp` table, launches a `meetup` stream, publishes data to Kafka, and allows sample queries. It uses the `upsert` QuickStart type.

```bash
docker run \
    -p 9000:9000 \
    apachepinot/pinot:0.9.3 QuickStart \
    -type upsert
```

```bash
./bin/pinot-admin.sh QuickStart -type upsert
```

--------------------------------

### Run Pinot QuickStart for Batch Processing

Source: https://docs.pinot.apache.org/release-0.11.0/basics/getting-started/quick-start

This example demonstrates how to perform batch processing with Pinot. It starts Apache Zookeeper, Pinot Controller, Broker, and Server, creates a 'baseballStats' table, launches a standalone data ingestion job for a CSV file, and issues sample queries.

```docker
docker run \
    -p 9000:9000 \
    apachepinot/pinot:0.11.0 QuickStart \
    -type batch
```

```bash
./bin/pinot-admin.sh QuickStart -type batch
```

--------------------------------

### Run Apache Pinot Batch JSON QuickStart

Source: https://docs.pinot.apache.org/basics/getting-started/quick-start

This example demonstrates how to import and query JSON documents within Pinot. It starts Apache Zookeeper, Pinot Controller, Broker, and Server, creates the `githubEvents` table, launches a standalone data ingestion job to build a segment from a JSON data file, pushes it to the Pinot Controller, and then issues sample queries.

```docker
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type batch_json_index
```

```bash
./bin/pinot-admin.sh QuickStart -type batch_json_index
```

```bash
pinot-admin QuickStart -type batch_json_index
```

--------------------------------

### Run Apache Pinot QuickStart for Streaming Complex Data Types

Source: https://docs.pinot.apache.org/release-0.12.1/basics/getting-started/quick-start

This example illustrates stream processing in Apache Pinot for data containing complex fields requiring unnesting. It starts Kafka, Zookeeper, and Pinot components (including Minion), creates a `meetupRsvp` table, launches a `meetup` stream, publishes data to Kafka, and supports sample queries. It uses the `stream_complex_type` QuickStart type.

```bash
docker run \
    -p 9000:9000 \
    apachepinot/pinot:0.9.3 QuickStart \
    -type stream_complex_type
```

```bash
./bin/pinot-admin.sh QuickStart -type stream_complex_type
```

--------------------------------

### Run Apache Pinot Batch JSON Ingestion QuickStart

Source: https://docs.pinot.apache.org/release-1.0.0/basics/getting-started/quick-start

Demonstrates how to import and query JSON documents in Apache Pinot. This command starts all necessary Pinot components, creates a `githubEvents` table, ingests a JSON data file, and issues sample queries.

```Shell
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type batch_json_index
```

```Shell
./bin/pinot-admin.sh QuickStart -type batch_json_index
```

--------------------------------

### Run Apache Pinot QuickStart for Hybrid Stream and Batch Processing

Source: https://docs.pinot.apache.org/release-0.12.1/basics/getting-started/quick-start

This example demonstrates hybrid stream and batch processing capabilities in Apache Pinot. It sets up Kafka, Zookeeper, and Pinot components, creates an `airlineStats` table, performs standalone data ingestion for Avro files, launches a stream of flight statistics, publishes data to Kafka, and supports sample queries. It uses the `hybrid` QuickStart type.

```bash
docker run \
    -p 9000:9000 \
    apachepinot/pinot:0.9.3 QuickStart \
    -type hybrid
```

```bash
./bin/pinot-admin.sh QuickStart -type hybrid
```

--------------------------------

### Run Pinot Streaming QuickStart

Source: https://docs.pinot.apache.org/release-0.10.0/basics/getting-started/quick-start

Demonstrates real-time stream processing with Pinot. This command starts Apache Kafka, Apache Zookeeper, Pinot Controller, Broker, and Server, creates the 'meetupRsvp' table, launches a 'meetup' stream, publishes data to a Kafka topic, and issues sample queries.

```docker
docker run \
    -p 9000:9000 \
    apachepinot/pinot:0.9.3 QuickStart \
    -type stream
```

```bash
./bin/pinot-admin.sh QuickStart -type stream
```

--------------------------------

### Install and Start Pinot Locally

Source: https://docs.pinot.apache.org/release-1.0.0/for-users/clients/golang

This command initiates a local Apache Pinot instance using a quickstart script, which is a prerequisite for connecting with the Go client.

```Shell
bin/quick-start-batch.sh
```

--------------------------------

### Run Apache Pinot QuickStart for Join Operations

Source: https://docs.pinot.apache.org/release-1.0.0/basics/getting-started/quick-start

This example illustrates how to perform join operations in Apache Pinot using the Lookup UDF. It starts Zookeeper and Pinot components, creates `baseballStats` and `dimBaseballTeams` tables, ingests CSV data for both, and enables sample queries. This demonstrates how to enrich data by joining fact and dimension tables within Pinot.

```bash
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type join
```

```bash
./bin/pinot-admin.sh QuickStart -type join
```

--------------------------------

### Run Pinot QuickStart for Batch Processing

Source: https://docs.pinot.apache.org/release-0.12.0/basics/getting-started/quick-start

This example demonstrates how to perform batch processing with Apache Pinot. It starts all necessary Pinot components (Zookeeper, Controller, Broker, Server), creates a 'baseballStats' table, launches a standalone data ingestion job for a CSV file, and pushes the segment to the Pinot Controller. Finally, it issues sample queries to Pinot.

```docker
docker run \
    -p 9000:9000 \
    apachepinot/pinot:0.9.3 QuickStart \
    -type batch
```

```bash
./bin/pinot-admin.sh QuickStart -type batch
```

--------------------------------

### Run Apache Pinot QuickStart Hybrid Example

Source: https://docs.pinot.apache.org/release-1.2.0/basics/getting-started/quick-start

This example demonstrates hybrid stream and batch processing with Apache Pinot. It sets up Kafka, Zookeeper, and Pinot components, creates an 'airlineStats' table, ingests both batch Avro files and a stream of flight data from Kafka, and allows for sample queries.

```shell
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type hybrid
```

```shell
./bin/pinot-admin.sh QuickStart -type hybrid
```

```shell
pinot-admin QuickStart -type hybrid
```

--------------------------------

### Run Apache Pinot QuickStart Join Example

Source: https://docs.pinot.apache.org/release-1.2.0/basics/getting-started/quick-start

This example illustrates how to perform data joins in Apache Pinot using the Lookup UDF. It initializes Pinot components, creates 'baseballStats' and 'dimBaseballTeams' tables, ingests CSV data for both, and enables querying with join operations.

```shell
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type join
```

```shell
./bin/pinot-admin.sh QuickStart -type join
```

```shell
pinot-admin QuickStart -type join
```

--------------------------------

### Run Pinot QuickStart for Batch Processing with Complex Data Types

Source: https://docs.pinot.apache.org/release-0.11.0/basics/getting-started/quick-start

This example demonstrates batch processing in Pinot where data items contain complex fields that require unnesting. It sets up Pinot components, creates a 'githubEvents' table, ingests JSON data, and supports sample queries.

```docker
docker run \
    -p 9000:9000 \
    apachepinot/pinot:0.11.0 QuickStart \
    -type batch_json_index
```

```bash
./bin/pinot-admin.sh QuickStart -type batch_json_index
```

--------------------------------

### Run Apache Pinot Batch Processing QuickStart

Source: https://docs.pinot.apache.org/release-1.0.0/basics/getting-started/quick-start

Demonstrates how to perform batch processing with Apache Pinot. This command starts all necessary Pinot components (Zookeeper, Controller, Broker, Server), creates a `baseballStats` table, ingests a CSV data file, and issues sample queries.

```Shell
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type batch
```

```Shell
./bin/pinot-admin.sh QuickStart -type batch
```

--------------------------------

### Run Pinot QuickStart for Streaming Processing

Source: https://docs.pinot.apache.org/release-0.12.0/basics/getting-started/quick-start

This example demonstrates how to perform stream processing using Apache Pinot. It starts Apache Kafka along with all Pinot components, creates a 'meetupRsvp' table, and launches a 'meetup' stream. Data is published to a Kafka topic ('meetupRSVPEvents') which Pinot subscribes to, allowing for real-time ingestion and subsequent sample queries.

```docker
docker run \
    -p 9000:9000 \
    apachepinot/pinot:0.9.3 QuickStart \
    -type stream
```

```bash
./bin/pinot-admin.sh QuickStart -type stream
```

--------------------------------

### Run Apache Pinot QuickStart for Streaming JSON Data

Source: https://docs.pinot.apache.org/release-1.0.0/basics/getting-started/quick-start

This example focuses on stream processing JSON documents within Apache Pinot. It configures Pinot to handle JSON data, setting up the necessary components, creating a `meetupRsvp` table, launching a `meetup` stream, and ingesting JSON data from Kafka for querying.

```Shell
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type stream_json_index
```

```Shell
./bin/pinot-admin.sh QuickStart -type stream_json_index
```

--------------------------------

### Run Apache Pinot QuickStart for Upsert JSON Streaming

Source: https://docs.pinot.apache.org/release-0.12.1/basics/getting-started/quick-start

This example demonstrates stream processing with upsert functionality for JSON documents in Apache Pinot. It initializes Kafka, Zookeeper, and Pinot components, creates a `meetupRsvp` table, launches a `meetup` stream, publishes data to Kafka, and allows sample queries. It uses the `upsert_json_index` QuickStart type.

```bash
docker run \
    -p 9000:9000 \
    apachepinot/pinot:0.9.3 QuickStart \
    -type upsert_json_index
```

```bash
./bin/pinot-admin.sh QuickStart -type upsert_json_index
```

--------------------------------

### Run Apache Pinot Batch Complex Data Types QuickStart

Source: https://docs.pinot.apache.org/release-1.0.0/basics/getting-started/quick-start

Demonstrates batch processing in Apache Pinot for data items with complex fields that require unnesting. This command starts all necessary Pinot components, creates a `githubEvents` table, ingests a JSON data file, and issues sample queries.

```Shell
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type batch_complex_type
```

```Shell
./bin/pinot-admin.sh QuickStart -type batch_complex_type
```

--------------------------------

### Run Apache Pinot QuickStart for Join Operations with Lookup UDF

Source: https://docs.pinot.apache.org/release-1.3.0/basics/getting-started/quick-start

This example demonstrates performing join operations in Apache Pinot using the Lookup UDF. It initializes Pinot components, creates `baseballStats` and `dimBaseballTeams` tables, and ingests CSV data to prepare for join queries.

```Shell
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type join
```

```Shell
./bin/pinot-admin.sh QuickStart -type join
```

```Shell
pinot-admin QuickStart -type join
```

--------------------------------

### Execute Pinot Quickstart Batch Example Script

Source: https://docs.pinot.apache.org/release-1.1.0/for-users/clients/python

Runs a sample Python script from the `pinot-dbapi` examples directory that queries the locally running Pinot Quickstart instance. This demonstrates end-to-end usage with the quickstart setup.

```Shell
python3 examples/pinot-quickstart-batch.py
```

--------------------------------

### Quick Start for Pinot GitHub Events Setup

Source: https://docs.pinot.apache.org/release-1.2.0/basics/recipes/github-events-stream

A simplified Docker command to quickly set up and stream GitHub events into Pinot. This command encapsulates multiple setup steps into a single execution, providing a fast way to get started.

```bash
docker run --rm -ti \
    --network=pinot-demo \
    --name pinot-github-events-quick-start \
     ${PINOT_IMAGE} GitHubEventsQuickStart \
    -personalAccessToken <your_github_personal_access_token>
```

--------------------------------

### Verify Helm Installation and Version

Source: https://docs.pinot.apache.org/release-0.11.0/basics/getting-started/public-cloud-examples/aws-quickstart

Checks the installed version of Helm to confirm successful installation and compatibility with QuickStart scripts.

```bash
helm version
```

--------------------------------

### Build and Run Pinot Go Client Example

Source: https://docs.pinot.apache.org/release-1.3.0/for-users/clients/golang

Builds the batch quickstart example application from the cloned Go client repository and then executes it to demonstrate querying Pinot.

```Bash
go build ./examples/batch-quickstart
./batch-quickstart
```

--------------------------------

### Build and Run Go Client Example Application

Source: https://docs.pinot.apache.org/users/clients/golang

These commands compile the provided batch quickstart example application within the Go client repository and then execute it, demonstrating basic interaction with a local Pinot instance.

```bash
go build ./examples/batch-quickstart
./batch-quickstart
```

--------------------------------

### Run Apache Pinot Basic Streaming QuickStart

Source: https://docs.pinot.apache.org/basics/getting-started/quick-start

Demonstrates basic stream processing with Apache Pinot, setting up Kafka, Zookeeper, and Pinot components to ingest data into a `meetupRsvp` table and enable querying.

```Docker
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type stream
```

```Shell
./bin/pinot-admin.sh QuickStart -type stream
```

```Shell
pinot-admin QuickStart -type stream
```

--------------------------------

### Run Pinot Quickstart Batch Script

Source: https://docs.pinot.apache.org/release-1.1.0/for-users/clients/golang

Executes the quickstart batch script to set up and run Apache Pinot locally, typically used for initial environment setup as part of the quickstart guide.

```bash
bin/quick-start-batch.sh
```

--------------------------------

### Run Apache Pinot QuickStart for Streaming with Minion Cleanup

Source: https://docs.pinot.apache.org/release-1.3.0/basics/getting-started/quick-start

Demonstrates stream processing in Apache Pinot with RealtimeToOfflineSegmentsTask and MergeRollupTask minion tasks for continuous segment optimization. This command starts Kafka, Zookeeper, Pinot components (Controller, Broker, Minion, Server), creates a `githubEvents` table, launches a GitHub events stream, publishes data to a Kafka topic, and allows sample queries to Pinot.

```bash
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type realtime_minion
```

```bash
./bin/pinot-admin.sh QuickStart -type realtime_minion
```

```bash
pinot-admin QuickStart -type realtime_minion
```

--------------------------------

### SQL Usage Example for SEGMENTPARTITIONEDDISTINCTCOUNT

Source: https://docs.pinot.apache.org/release-0.10.0/configuration-reference/functions/segmentpartitioneddistinctcount

An example demonstrating how to use the SEGMENTPARTITIONEDDISTINCTCOUNT function within a SQL query to get the distinct count of 'teamID' from the 'baseballStats' table. This example is based on the Batch Quick Start.

```SQL
select SEGMENTPARTITIONEDDISTINCTCOUNT(teamID) AS value
from baseballStats
```

--------------------------------

### Run Apache Pinot QuickStart for upserting JSON data

Source: https://docs.pinot.apache.org/release-1.1.0/basics/getting-started/quick-start

Demonstrates stream processing with upsert functionality for JSON documents in Apache Pinot. This setup starts Apache Kafka, Apache Zookeeper, Pinot Controller, Pinot Broker, and Pinot Server, then creates a 'meetupRsvp' table, launches a 'meetup' stream, and publishes data to a Kafka topic 'meetupRSVPEvents' for Pinot to subscribe to.

```bash
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type upsert_json_index
```

```bash
./bin/pinot-admin.sh QuickStart -type upsert_json_index
```

```bash
pinot-admin QuickStart -type upsert_json_index
```

--------------------------------

### Build and Run Pinot Go Client Example

Source: https://docs.pinot.apache.org/release-1.1.0/for-users/clients/golang

Builds the example application from the Go client repository and then executes it to query data from a local Pinot instance, demonstrating basic client usage with the batch quickstart.

```bash
go build ./examples/batch-quickstart
./batch-quickstart
```

--------------------------------

### Run Apache Pinot QuickStart on M1/M2 Mac with Docker

Source: https://docs.pinot.apache.org/release-1.0.0/basics/getting-started/quick-start

This command runs the Apache Pinot QuickStart batch example using Docker, specifically tailored for macOS devices with M1 or M2 CPUs by using the `-arm64` suffix in the Docker image tag. It maps port 9000 for Pinot access.

```Shell
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest-arm64 QuickStart \
    -type batch
```

--------------------------------

### Run Apache Pinot QuickStart for streaming complex data types

Source: https://docs.pinot.apache.org/release-1.1.0/basics/getting-started/quick-start

Demonstrates stream processing in Apache Pinot where the stream contains items that have complex fields requiring unnesting. This setup starts Apache Kafka, Apache Zookeeper, Pinot Controller, Pinot Broker, Pinot Minion, and Pinot Server, then creates a 'meetupRsvp' table, launches a 'meetup' stream, and publishes data to a Kafka topic 'meetupRSVPEvents' for Pinot to subscribe to.

```bash
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type stream_complex_type
```

```bash
./bin/pinot-admin.sh QuickStart -type stream_complex_type
```

```bash
pinot-admin QuickStart -type stream_complex_type
```

--------------------------------

### Run Pinot Quick Start Example

Source: https://docs.pinot.apache.org/release-1.3.0/basics/getting-started/running-pinot-locally

Example command to launch a Pinot instance with a pre-built dataset using the quick start utility. This simplifies setting up a functional Pinot environment for demonstration or testing.

```bash
./bin/pinot-admin.sh QuickStart -type batch
```

--------------------------------

### Pinot Launcher Scripts Setup: Download, Extract, and Start Components

Source: https://docs.pinot.apache.org/release-1.0.0/for-developers/advanced/advanced-pinot-setup

Details how to set up Apache Pinot using its provided launcher scripts. It includes steps for downloading and extracting the Pinot distribution, setting the installation directory, and then starting Zookeeper, Pinot Controller, Broker, and Server components using the `pinot-admin.sh` script.

```bash
export PINOT_VERSION=0.10.0
tar -xvf apache-pinot-${PINOT_VERSION}-bin.tar.gz

cd apache-pinot-${PINOT_VERSION}-bin
ls

PINOT_INSTALL_DIR=`pwd`
```

```bash
cd apache-pinot-${PINOT_VERSION}-bin
bin/pinot-admin.sh StartZookeeper
```

```bash
bin/pinot-admin.sh StartController \
    -zkAddress localhost:2181
```

```bash
bin/pinot-admin.sh StartBroker \
    -zkAddress localhost:2181
```

```bash
bin/pinot-admin.sh StartServer \
    -zkAddress localhost:2181
```

--------------------------------

### Configure Basic Streaming with Apache Pinot

Source: https://docs.pinot.apache.org/release-1.2.0/basics/getting-started/quick-start

This example demonstrates how to set up basic stream processing in Apache Pinot. It involves starting essential components like Kafka, Zookeeper, and Pinot services, creating a `meetupRsvp` table, launching a stream, publishing data to a Kafka topic, and issuing sample queries to Pinot.

```bash
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type stream
```

```bash
./bin/pinot-admin.sh QuickStart -type stream
```

```bash
pinot-admin QuickStart -type stream
```

--------------------------------

### Start Zookeeper with Pinot Launcher Script

Source: https://docs.pinot.apache.org/release-1.3.0/for-developers/advanced/advanced-pinot-setup

Navigates to the Pinot installation directory and starts the Zookeeper component using the provided `pinot-admin.sh` launcher script. This is an alternative to running Zookeeper via Docker.

```bash
cd apache-pinot-${PINOT_VERSION}-bin
bin/pinot-admin.sh StartZookeeper
```

--------------------------------

### SQL Usage Example for ST_GeometryType

Source: https://docs.pinot.apache.org/release-1.1.0/configuration-reference/functions/stgeometrytype

Demonstrates how to use the ST_GeometryType function within a SQL query to extract and display the geometry type from a 'location' column. This example is based on the Streaming Quick Start guide.

```SQL
select location, ST_GeometryType(location) AS type
from meetupRsvp 
LIMIT 1
```

--------------------------------

### SQL SUBSTR Example: Extracting from Index 0 to 2

Source: https://docs.pinot.apache.org/release-0.10.0/configuration-reference/functions/substr

Illustrates the use of the SUBSTR function in SQL to extract a substring starting from index 0 up to (but not including) index 2. This example shows how to get the first two characters of a string.

```SQL
select SUBSTR('Pinot', 0, 2) AS name
FROM ignoreMe
```

--------------------------------

### Set Up and Start Spark in Local Mode

Source: https://docs.pinot.apache.org/release-0.4.0/operators/tutorials/batch-data-ingestion-in-practice

These commands demonstrate how to download, extract, and start Apache Spark in local mode. This setup is useful for running Spark-based Pinot ingestion jobs locally.

```bash
wget https://downloads.apache.org/spark/spark-2.4.5/spark-2.4.5-bin-hadoop2.7.tgz
tar xvf spark-2.4.5-bin-hadoop2.7.tgz
cd spark-2.4.5-bin-hadoop2.7
./bin/spark-shell --master 'local[2]'
```

--------------------------------

### Run Apache Pinot QuickStart for Streaming with Minion Cleanup

Source: https://docs.pinot.apache.org/release-0.10.0/basics/getting-started/quick-start

This example demonstrates stream processing in Apache Pinot with continuous segment optimization using RealtimeToOfflineSegmentsTask and MergeRollupTask minion tasks. It sets up a Pinot cluster with Kafka, Zookeeper, and Minion components, creates a `githubEvents` table, launches a GitHub events stream, and ingests data from Kafka for optimized processing.

```Shell
docker run \
    -p 9000:9000 \
    apachepinot/pinot:0.9.3 QuickStart \
    -type realtime_minion
```

```Shell
./bin/pinot-admin.sh QuickStart -type realtime_minion
```

--------------------------------

### Run Apache Pinot Streaming with Minion Cleanup QuickStart

Source: https://docs.pinot.apache.org/basics/getting-started/quick-start

Demonstrates stream processing in Apache Pinot with continuous segment optimization using RealtimeToOfflineSegmentsTask and MergeRollupTask minion tasks. It sets up Kafka, Zookeeper, Pinot components, and a Pinot Minion to ingest GitHub events.

```Docker
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type realtime_minion
```

```Shell
./bin/pinot-admin.sh QuickStart -type realtime_minion
```

```Shell
pinot-admin QuickStart -type realtime_minion
```

--------------------------------

### Run Apache Pinot QuickStart for Streaming Complex Data Types

Source: https://docs.pinot.apache.org/release-1.3.0/basics/getting-started/quick-start

Demonstrates stream processing in Apache Pinot where the stream contains items with complex fields requiring unnesting. This command starts Kafka, Zookeeper, Pinot components (Controller, Broker, Minion, Server), creates a `meetupRsvp` table, launches a `meetup` stream, publishes data to a Kafka topic, and allows sample queries to Pinot.

```bash
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type stream_complex_type
```

```bash
./bin/pinot-admin.sh QuickStart -type stream_complex_type
```

```bash
pinot-admin QuickStart -type stream_complex_type
```

--------------------------------

### Run Pinot Batch JSON Indexing QuickStart

Source: https://docs.pinot.apache.org/release-0.10.0/basics/getting-started/quick-start

Demonstrates how to import and query JSON documents in Pinot. This command starts Apache Zookeeper, Pinot Controller, Broker, and Server, creates the 'githubEvents' table, launches a standalone data ingestion job for a given JSON data file, and issues sample queries.

```docker
docker run \
    -p 9000:9000 \
    apachepinot/pinot:0.9.3 QuickStart \
    -type batch_json_index
```

```bash
./bin/pinot-admin.sh QuickStart -type batch_json_index
```

--------------------------------

### Start Apache Pinot Minion with Launcher Script

Source: https://docs.pinot.apache.org/release-1.0.0/basics/components/cluster/minion

Example command to start the Apache Pinot Minion using the provided `pinot-admin.sh` launcher script. This method requires a local installation of Pinot and specifies the Zookeeper address.

```bash
bin/pinot-admin.sh StartMinion \
    -zkAddress localhost:2181
```

--------------------------------

### Start Kafka and Zookeeper for Pinot Streaming

Source: https://docs.pinot.apache.org/release-0.10.0/developers/advanced/advanced-pinot-setup

Commands to initialize Kafka and its Zookeeper dependency, essential for Pinot's streaming ingestion. Examples provided for both Docker container setup and direct execution via Pinot launcher scripts.

```shell
docker run \
    --network pinot-demo --name=kafka \
    -e KAFKA_ZOOKEEPER_CONNECT=pinot-zookeeper:2181/kafka \
    -e KAFKA_BROKER_ID=0 \
    -e KAFKA_ADVERTISED_HOST_NAME=kafka \
    -d wurstmeister/kafka:latest
```

```shell
bin/pinot-admin.sh StartZookeeper -zkPort 2191
```

```shell
bin/pinot-admin.sh  StartKafka -zkAddress=localhost:2191/kafka -port 19092
```

--------------------------------

### Build and Run Pinot Client Go Example

Source: https://docs.pinot.apache.org/release-0.4.0/users/clients/golang

Builds the example application provided with the Pinot Go client and then executes it to demonstrate querying a local Pinot instance.

```bash
go build ./examples/batch-quickstart
./batch-quickstart
```

--------------------------------

### SQL Example for ST_Union Function

Source: https://docs.pinot.apache.org/release-0.11.0/configuration-reference/functions/stunion

Demonstrates how to use the ST_Union function in a SQL query to aggregate location data by city, convert the resulting geometry to text, and order the results. This example is based on the Streaming Quick Start guide.

```SQL
select group_city, ST_AsText(STUnion(location)) AS unionString
from meetupRsvp 
GROUP BY group_city
ORDER BY STUnion(location) DESC
LIMIT 5
```

--------------------------------

### Run Apache Pinot Upsert QuickStart

Source: https://docs.pinot.apache.org/basics/getting-started/quick-start

Demonstrates stream processing with upsert functionality in Apache Pinot, setting up Kafka, Zookeeper, and Pinot components to handle data updates and deduplication for a `meetupRsvp` table.

```Docker
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type upsert
```

```Shell
./bin/pinot-admin.sh QuickStart -type upsert
```

```Shell
pinot-admin QuickStart -type upsert
```

--------------------------------

### Calculate sum of hits in baseballStats using SQL

Source: https://docs.pinot.apache.org/release-0.10.0/configuration-reference/functions/sum

This SQL example demonstrates how to use the SUM aggregate function to calculate the total number of 'hits' from the 'baseballStats' table. The result is aliased as 'value'. This example is based on the Batch Quick Start guide.

```sql
select sum(hits) AS value
from baseballStats
```

--------------------------------

### Run Apache Pinot QuickStart for Streaming JSON Documents

Source: https://docs.pinot.apache.org/release-1.3.0/basics/getting-started/quick-start

Demonstrates stream processing with JSON documents in Apache Pinot. This command starts Kafka, Zookeeper, and Pinot components, creates a `meetupRsvp` table, launches a `meetup` stream, publishes data to a Kafka topic, and allows sample queries to Pinot, specifically configured for JSON indexing.

```bash
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type stream_json_index
```

```bash
./bin/pinot-admin.sh QuickStart -type stream_json_index
```

```bash
pinot-admin QuickStart -type stream_json_index
```

--------------------------------

### Run Apache Pinot QuickStart for Basic Upsert Streaming

Source: https://docs.pinot.apache.org/release-1.0.0/basics/getting-started/quick-start

This example illustrates basic stream processing with upsert functionality in Apache Pinot. It configures Pinot to support upserts, setting up the core components, creating a `meetupRsvp` table, launching a `meetup` stream, and ingesting data from Kafka where new records can update existing ones.

```Shell
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type upsert
```

```Shell
./bin/pinot-admin.sh QuickStart -type upsert
```

--------------------------------

### Pinot Docker Setup: Pull Image, Create Network, and Start Components

Source: https://docs.pinot.apache.org/release-1.0.0/for-developers/advanced/advanced-pinot-setup

Provides a comprehensive guide to setting up Apache Pinot using Docker. It covers pulling the Pinot Docker image, creating a dedicated network, and sequentially starting Zookeeper, ZKUI, Pinot Controller, Broker, and Server containers, along with a command to check container status.

```bash
export PINOT_VERSION=0.10.0
export PINOT_IMAGE=apachepinot/pinot:${PINOT_VERSION}
docker pull ${PINOT_IMAGE}
```

```bash
docker network create -d bridge pinot-demo
```

```bash
docker run \
    --network=pinot-demo \
    --name  pinot-zookeeper \
    --restart always \
    -p 2181:2181 \
    -d zookeeper:3.5.6
```

```bash
docker run \
    --network pinot-demo --name=zkui \
    -p 9090:9090 \
    -e ZK_SERVER=pinot-zookeeper:2181 \
    -d qnib/plain-zkui:latest
```

```bash
docker run \
    --network=pinot-demo \
    --name pinot-controller \
    -p 9000:9000 \
    -d ${PINOT_IMAGE} StartController \
    -zkAddress pinot-zookeeper:2181
```

```bash
docker run \
    --network=pinot-demo \
    --name pinot-broker \
    -d ${PINOT_IMAGE} StartBroker \
    -zkAddress pinot-zookeeper:2181
```

```bash
export PINOT_IMAGE=apachepinot/pinot:0.3.0-SNAPSHOT
docker run \
    --network=pinot-demo \
    --name pinot-server \
    -d ${PINOT_IMAGE} StartServer \
    -zkAddress pinot-zookeeper:2181
```

```bash
docker container ls -a
```

--------------------------------

### Run Apache Pinot QuickStart for Streaming with Upsert

Source: https://docs.pinot.apache.org/release-1.3.0/basics/getting-started/quick-start

Demonstrates stream processing with upsert functionality in Apache Pinot. This command starts Kafka, Zookeeper, and Pinot components, creates a `meetupRsvp` table, launches a `meetup` stream, publishes data to a Kafka topic, and allows sample queries to Pinot, configured for upsert operations.

```bash
docker run \
    -p 9000:9000 \
    apachepinot/pinot:latest QuickStart \
    -type upsert
```

```bash
./bin/pinot-admin.sh QuickStart -type upsert
```

```bash
pinot-admin QuickStart -type upsert
```

--------------------------------

### Apache Pinot Quick Start Upsert Streaming Table Setup

Source: https://docs.pinot.apache.org/release-1.0.0/basics/data-import/upsert

This bash command initiates the quick start example for an Apache Pinot upsert streaming table. It's used to set up the 'meetupRSVP' table, stopping any previously running quick start clusters to ensure a clean environment.

```bash
# stop previous quick start cluster, if any
bin/quick-start-upsert-streaming.sh
```