YugabyteDB

https://github.com/yugabyte/yugabyte-db
Admin
YugabyteDB is a PostgreSQL-compatible, high-performance, cloud-native, distributed SQL database that...
Tokens:5,973,538
Snippets:39,254
Trust Score:8.5
Update:2 days ago
Show doc for...
Tokens:
Raw
### Complete Example - pg_dist_rag Setup and Usage

Source: https://github.com/yugabyte/yugabyte-db/blob/master/src/postgres/yb-extensions/pg_dist_rag/README.md

A complete example showing how to install the extension, create sources, initialize a vector index, build the index, and monitor progress using the pg_dist_rag functions and views.

```APIDOC
## Complete Example - pg_dist_rag Setup and Usage

### Description
This example demonstrates the full workflow: installing the extension, creating document sources, initializing a vector index, building the index, and monitoring progress.

### Step 1: Install the extension
```sql
CREATE EXTENSION IF NOT EXISTS pg_dist_rag;
```

### Step 2: Create document sources
```sql
SELECT dist_rag.create_source(
  r_source_uri := 'https://docs.example.com/api-reference/'
) AS api_source_id;
-- returns: e.g. 'a1b2c3d4-...'

SELECT dist_rag.create_source(
  r_source_uri := 's3://company-docs/engineering/',
  r_metadata := '{"team": "engineering", "access": "internal"}'::jsonb,
  r_secrets_provider := 'AWS',
  r_secrets_provider_params := '{"region": "us-east-1"}'::jsonb
) AS eng_source_id;
-- returns: e.g. 'e5f6g7h8-...'
```

### Step 3: Initialize a vector index with both sources
```sql
SELECT dist_rag.init_vector_index(
  r_index_name := 'engineering_kb',
  r_sources := ARRAY['a1b2c3d4-...', 'e5f6g7h8-...']::UUID[],
  r_ai_provider := 'OPENAI',
  r_embedding_model_params := '{"dimensions": 1536, "model": "text-embedding-ada-002"}'::jsonb
);
```

### Step 4: Build the index (queues all documents for preprocessing)
```sql
SELECT dist_rag.build_index(r_index_name := 'engineering_kb');
```

### Step 5: Monitor progress
```sql
SELECT index_name, document_name, pipeline_status, chunks_processed, current_step
FROM dist_rag.vector_index_pipeline_details
WHERE index_name = 'engineering_kb';
```

### Step 6: Check overall stats
```sql
SELECT document_name, calls, total_chunks_processed, completion_rate_percent
FROM dist_rag.pipeline_stats
WHERE index_name = 'engineering_kb';
```
```

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

### Complete Example: Install, Create Sources, Init, Build, Monitor

Source: https://github.com/yugabyte/yugabyte-db/blob/master/src/postgres/yb-extensions/pg_dist_rag/README.md

A step-by-step complete example of using pg_dist_rag: install the extension, create document sources, initialize a vector index with both sources, build the index, and monitor progress via pipeline details and stats. Includes example return values for source creation.

```sql
-- Step 1: Install the extension
CREATE EXTENSION IF NOT EXISTS pg_dist_rag;

-- Step 2: Create document sources
SELECT dist_rag.create_source(
  r_source_uri := 'https://docs.example.com/api-reference/'
) AS api_source_id;
-- returns: e.g. 'a1b2c3d4-...'

SELECT dist_rag.create_source(
  r_source_uri := 's3://company-docs/engineering/',
  r_metadata := '{"team": "engineering", "access": "internal"}'::jsonb,
  r_secrets_provider := 'AWS',
  r_secrets_provider_params := '{"region": "us-east-1"}'::jsonb
) AS eng_source_id;
-- returns: e.g. 'e5f6g7h8-...'

-- Step 3: Initialize a vector index with both sources
SELECT dist_rag.init_vector_index(
  r_index_name := 'engineering_kb',
  r_sources := ARRAY['a1b2c3d4-...', 'e5f6g7h8-...']::UUID[],
  r_ai_provider := 'OPENAI',
  r_embedding_model_params := '{"dimensions": 1536, "model": "text-embedding-ada-002"}'::jsonb
);

-- Step 4: Build the index (queues all documents for preprocessing)
SELECT dist_rag.build_index(r_index_name := 'engineering_kb');

-- Step 5: Monitor progress
SELECT index_name, document_name, pipeline_status, chunks_processed, current_step
FROM dist_rag.vector_index_pipeline_details
WHERE index_name = 'engineering_kb';

-- Step 6: Check overall stats
SELECT document_name, calls, total_chunks_processed, completion_rate_percent
FROM dist_rag.pipeline_stats
WHERE index_name = 'engineering_kb';
```

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

### cargo pgrx install examples

Source: https://github.com/yugabyte/yugabyte-db/blob/master/src/postgres/third-party-extensions/pgrx/skills/cargo-pgrx/install.md

Examples of installing an extension with default settings, to a specific Postgres installation, in release mode, and with sudo for root-required directories.

```bash
# Install to default pg_config
cargo pgrx install

# Install to a specific Postgres installation
cargo pgrx install --pg-config /usr/local/pgsql/bin/pg_config

# Release build for production
cargo pgrx install --release

# Install when extension dir requires root
cargo pgrx install --release --sudo
```

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

### Run node agent installer with example values

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/yugabyte-platform/prepare/server-nodes-software/software-on-prem-manual.md

Example command to install node agent, with an optional flag to skip YBA certificate verification. The output shows the interactive configuration prompts and successful registration.

```sh
# To ignore verification of YBA certificate, add --skip_verify_cert.
./installer.sh  -c install -u https://10.98.0.42 -t 301fc382-cf06-4a1b-b5ef-0c8c45273aef
```

```output
* Starting YB Node Agent install
* Creating Node Agent Directory
* Changing directory to node agent
* Creating Sub Directories
* Downloading YB Node Agent build package
* Getting Linux/amd64 package
* Downloaded Version - 2.17.1.0-PRE_RELEASE
* Extracting the build package
* The current value of Node IP is not set; Enter new value or enter to skip: 10.9.198.2
* The current value of Node Name is not set; Enter new value or enter to skip: Test
* Select your Onprem Provider
1. Provider ID: 41ac964d-1db2-413e-a517-2a8d840ff5cd, Provider Name: onprem
        Enter the option number: 1
* Select your Instance Type
1. Instance Code: c5.large
        Enter the option number: 1
* Select your Region
1. Region ID: dc0298f6-21bf-4f90-b061-9c81ed30f79f, Region Code: us-west-2
        Enter the option number: 1
* Select your Zone
1. Zone ID: 99c66b32-deb4-49be-85f9-c3ef3a6e04bc, Zone Name: us-west-2c
        Enter the option number: 1
        • Completed Node Agent Configuration
        • Node Agent Registration Successful
You can install a systemd service on linux machines by running sudo node-agent-installer.sh -c install_service --user yugabyte (Requires sudo access).
```

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

### yba universe node start-master example

Source: https://github.com/yugabyte/yugabyte-db/blob/master/managed/yba-cli/docs/yba_universe_node_start-master.md

Example command that starts the master on a specified node in a universe.

```bash
yba universe node start-master --name <universe-name> --node-name <node-name>
```

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

### yba universe node start-processes example

Source: https://github.com/yugabyte/yugabyte-db/blob/master/managed/yba-cli/docs/yba_universe_node_start-processes.md

Example command to start processes on a node, using the --name and --node-name flags.

```bash
yba universe node start --name <universe-name> --node-name <node-name>
```

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

### yb-tserver example with master addresses and data directories

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/reference/configuration/yb-tserver.md

Example command to start yb-tserver with master addresses, RPC bind address, YSQL enabled, and data directories.

```sh
./bin/yb-tserver \
    --tserver_master_addrs 172.151.17.130:7100,172.151.17.220:7100,172.151.17.140:7100 \
    --rpc_bind_addresses 172.151.17.130 \
    --enable_ysql \
    --fs_data_dirs "/home/centos/disk1,/home/centos/disk2" &
```

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

### Run the extension

Source: https://github.com/yugabyte/yugabyte-db/blob/master/src/postgres/third-party-extensions/pgrx/README.md

Compile the extension, copy it to the Postgres installation, start Postgres, and connect to a database named after the extension.

```bash
cargo pgrx run
```

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

### Install and run Hydra CLI

Source: https://github.com/yugabyte/yugabyte-db/blob/master/src/postgres/third-party-extensions/pg_duckdb/README.md

Installs the hydra-cli package via pip and launches the Hydra interactive shell to get started with pg_duckdb.

```bash
pip install hydra-cli
hydra
```

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

### QuickStart.go - pgx.Connect() example

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/develop/drivers-orms/go/yb-pgx.md

Complete Go application demonstrating uniform and topology-aware load balancing with pgx.Connect(). Creates a table, inserts data, and runs queries. Includes commented example for read replica load balancing.

```go
package main

import (
    "bufio"
    "context"
    "fmt"
    "log"
    "os"
    "strconv"
    "time"

    "github.com/yugabyte/pgx/v5"
)

const (
    host     = "localhost"
    port     = 5433
    user     = "yugabyte"
    password = "yugabyte"
    dbname   = "yugabyte"
    numconns = 12
)

var connCloseChan chan int = make(chan int)
var baseUrl string = fmt.Sprintf("postgres://%s:%s@%s:%d/%s",
    user, password, host, port, dbname)

func main() {
    // Create a table and insert a row
    url := fmt.Sprintf("%s?load_balance=true", baseUrl)
    // If you have a read replica cluster and want to balance
    // connections across only read replica nodes,
    // set the load-balance property to 'only-rr' as follows:
    // url := fmt.Sprintf("%s?load_balance=only-rr", baseUrl)
    fmt.Printf("Connection url: %s\n", url)
    createTable(url)
    printAZInfo()
    pause()

    fmt.Println("---- Demonstrating uniform (cluster-aware) load balancing ----")
    executeQueries(url)
    fmt.Println("You can verify the connection counts on http://127.0.0.1:13000/rpcz and similar urls for other servers.")
    pause()
    closeConns(numconns)

    fmt.Println("---- Demonstrating topology-aware load balancing ----")
    url = fmt.Sprintf("%s?load_balance=true&topology_keys=cloud1.datacenter1.rack1", baseUrl)
    fmt.Printf("Connection url: %s\n", url)
    executeQueries(url)
    pause()
    closeConns(numconns)

    fmt.Println("Closing the application ...")
}

func closeConns(num int) {
    fmt.Printf("Closing %d connections ...\n", num)
    for i := 0; i < num; i++ {
        connCloseChan <- i
    }
}

func pause() {
    reader := bufio.NewReader(os.Stdin)
    fmt.Print("\nPress Enter/return to proceed: ")
    reader.ReadString('\n')
}

func createTable(url string) {
    conn, err := pgx.Connect(context.Background(), url)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Unable to connect to database: %v\n", err)
        os.Exit(1)
    }
    defer conn.Close(context.Background())

    var dropStmt = `DROP TABLE IF EXISTS employee`
    _, err = conn.Exec(context.Background(), dropStmt)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Exec for drop table failed: %v\n", err)
    }
    // The `conn.Exec()` function also returns an `error` object which,
    // if not `nil`, needs to be handled in your code.
    var createStmt = `CREATE TABLE employee (id int PRIMARY KEY,
                                             name varchar,
                                             age int,
                                             language varchar)`
    _, err = conn.Exec(context.Background(), createStmt)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Exec for create table failed: %v\n", err)
    }
    fmt.Println("Created table employee")
}
```

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

### Example PATH and environment variable setup for PostgreSQL 18

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/yugabyte-voyager/macos.md

Example output from Homebrew showing how to add PostgreSQL 18 to your PATH and set LDFLAGS and CPPFLAGS. Follow the exact instructions shown by Homebrew for your system.

```output
If you need to have postgresql@18 first in your PATH, run:
echo 'export PATH="/opt/homebrew/opt/postgresql@18/bin:$PATH"' >> ~/.zshrc
For compilers to find postgresql@18 you may need to set:
export LDFLAGS="-L/opt/homebrew/opt/postgresql@18/lib"
export CPPFLAGS="-I/opt/homebrew/opt/postgresql@18/include"
```

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

### Run YCQL Hello World with example connection parameters

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/develop/drivers-orms/java/ycql-ssl.md

Example command using a sample host, root certificate path, and credentials (admin/qwerty).

```sh
$ java -cp "target/hello-world-1.0.jar:target/lib/*" \
    com.yugabyte.sample.apps.YBCqlHelloWorld \
    42424242-42d0-4c1a-b424-d42424ab2f42.aws.yugabyte.cloud \
    src/main/resources/root.crt admin qwerty
```

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

### Install fish completions for every new session

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/yugabyte-cloud/managed-automation/managed-cli/_index.md

Installs fish completions for all new sessions. Start a new shell for the setup to take effect.

```sh
ybm completion fish > ~/.config/fish/completions/ybm.fish
```

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

### Get help for a specific yugabyted command

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/reference/configuration/yugabyted.md

Example of printing command-line help for the 'yugabyted start' command.

```sh
$ ./bin/yugabyted start -h
```

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

### Expected output of the QuickStart2.go application

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/develop/drivers-orms/go/yb-pgx.md

Sample output showing connection URLs, table creation, placement info, and load distribution for uniform and topology-aware load balancing. It includes prompts to press Enter to proceed.

```output
Connection url: postgres://yugabyte:yugabyte@localhost:5433/yugabyte?load_balance=true
Created table employee
Placement info details of cluster (127.0.0.1):
    AZ [cloud1.datacenter1.rack1]: 127.0.0.3, 127.0.0.2, 127.0.0.1,

Press Enter/return to proceed:
---- Demonstrating uniform (cluster-aware) load balancing ----
Creating 12 connections ...
Current load on cluster (127.0.0.1):
127.0.0.3                     :    4
127.0.0.2                     :    4
127.0.0.1                     :    4
You can verify the connection counts on http://127.0.0.1:13000/rpcz and similar urls for other servers.

Press Enter/return to proceed:
Closing 12 connections ...
---- Demonstrating topology-aware load balancing ----
Connection url: postgres://yugabyte:yugabyte@localhost:5433/yugabyte?load_balance=true&topology_keys=cloud1.datacenter1.rack1
Creating 12 connections ...
Current load on cluster (127.0.0.1):
127.0.0.1                     :    4
127.0.0.3                     :    4
127.0.0.2                     :    4

Press Enter/return to proceed:
Closing 12 connections ...
Closing the application ...
```

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

### Get help for universe list

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/yugabyte-platform/anywhere-automation/anywhere-cli.md

Example of printing command-line help for the cluster create command.

```sh
yba universe list -h
```

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

### Install completions for every new session on macOS

Source: https://github.com/yugabyte/yugabyte-db/blob/master/managed/yba-cli/docs/yba_completion_bash.md

Execute this command once to install the bash completions for all new sessions on macOS. You will need to start a new shell for the setup to take effect.

```bash
yba completion bash > $(brew --prefix)/etc/bash_completion.d/yba
```

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

### Example: Create table and insert data in session 1

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/explore/ysql-language-features/advanced-features/snapshot-synchronization.md

Creates a test table and inserts two rows. This is the initial setup for the snapshot synchronization example.

```sql
CREATE TABLE test(col INT);
INSERT INTO test VALUES (1), (2);
```

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

### TLDR: Full setup and build script

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/contribute/core-database/build-from-src-almalinux.md

Quick-start script that installs all dependencies, sets up environment variables, clones the repository, and runs the build. Modify shellrc to your preferred shell configuration file.

```sh
# Modify to your preference:
shellrc=~/.bashrc

sudo dnf update -y
sudo dnf groupinstall -y 'Development Tools'
sudo dnf -y install epel-release
packages=(
  ccache
  golang
  java-1.8.0-openjdk
  libatomic
  maven
  npm
  patchelf
  python3.11
  rsync
)
sudo dnf -y install "${packages[@]}"
sudo alternatives --set python3 /usr/bin/python3.9
latest_zip_url=$(curl -Ls "https://api.github.com/repos/ninja-build/ninja/releases/latest" \
                 | grep browser_download_url | grep ninja-linux.zip | cut -d \" -f 4)
curl -Ls "$latest_zip_url" | zcat | sudo tee /usr/local/bin/ninja >/dev/null
sudo chmod +x /usr/local/bin/ninja
sudo mkdir /opt/yb-build

# If you'd like to use an unprivileged user for development, manually
# run/modify instructions from here onwards (change $USER, make sure shell
# variables are set appropriately when switching users).
sudo chown "$USER" /opt/yb-build
mkdir ~/tools
curl -L "https://github.com/Kitware/CMake/releases/download/v3.31.0/cmake-3.31.0-linux-x86_64.tar.gz" | tar xzC ~/tools
source <(echo 'export PATH="$HOME/tools/cmake-3.31.0-linux-x86_64/bin:$PATH"' \
         | tee -a "$shellrc")
source <(echo 'export YB_CCACHE_DIR="$HOME/.cache/yb_ccache"' \
         | tee -a "$shellrc")

git clone https://github.com/yugabyte/yugabyte-db
cd yugabyte-db
./yb_release
```

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

### Install completions for every new session on Linux

Source: https://github.com/yugabyte/yugabyte-db/blob/master/managed/yba-cli/docs/yba_completion_bash.md

Execute this command once to install the bash completions for all new sessions on Linux. You will need to start a new shell for the setup to take effect.

```bash
yba completion bash > /etc/bash_completion.d/yba
```

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

### Install zsh completions for every new session

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/yugabyte-cloud/managed-automation/managed-cli/_index.md

Installs zsh completions for all new sessions. Includes commands for Linux and macOS. Start a new shell for the setup to take effect.

```sh
#### for Linux:
ybm completion zsh > "${fpath[1]}/_ybm"

#### for macOS:
ybm completion zsh > $(brew --prefix)/share/zsh/site-functions/_ybm
```

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

### Install bash completions for every new session

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/yugabyte-cloud/managed-automation/managed-cli/_index.md

Installs bash completions for all new sessions. Includes commands for Linux and macOS. Start a new shell for the setup to take effect.

```sh
#### for Linux:
ybm completion bash > /etc/bash_completion.d/ybm

#### for macOS:
ybm completion bash > $(brew --prefix)/etc/bash_completion.d/ybm
```

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

### Build and Install from Source

Source: https://github.com/yugabyte/yugabyte-db/blob/master/src/postgres/third-party-extensions/postgresql_anonymizer/docs/INSTALL.md

Step 2 for source installation: builds the extension and installs it using make commands.

```console
make extension
sudo make install
```

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

### Run the sample application

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/develop/tutorials/build-apps/python/cloud-ysql-python.md

Start the Python application.

```sh
$ python3 sample-app.py
```

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

### Start yugabyted with Resource Governance flags

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/additional-features/multitenancy/set-up.md

Example command to start yugabyted with flags that reserve 5% CPU for system work, cap each database at 25% of remaining CPU, and allow at most 20 databases. Requires manual root cgroup setup before running.

```sh
./bin/yugabyted start \
    --tserver_flags="enable_qos=true,qos_max_db_cpu_percent=25,qos_system_high_cpu_reserved_percent=5" \
    --master_flags="enable_qos=true,qos_max_db_cpu_percent=25,qos_system_high_cpu_reserved_percent=5,qos_max_db_count=20"
```

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

### Compile all examples

Source: https://github.com/yugabyte/yugabyte-db/blob/master/src/yb/rocksdb/examples/README.md

Run from the examples directory to build all example programs.

```shell
cd examples/; make all
```

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

### Start yugabyted example

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/reference/configuration/yugabyted.md

Example of starting a yugabyted node with the default settings.

```sh
$ ./bin/yugabyted start
```

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

### Download examples

Source: https://github.com/yugabyte/yugabyte-db/blob/master/managed/yba-cli/docs/yba_universe_file-collection_download.md

Two examples: the first downloads to the default location, the second downloads to a custom path and cleans up DB nodes after.

```bash
yba universe file-collection download --name <universe-name> --uuid <collection-uuid>
```

```bash
yba universe file-collection download --name <universe-name> --uuid <collection-uuid> \
  --path /tmp/diagnostics --cleanup-db-nodes-after
```

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

### Create a database and collection

Source: https://github.com/yugabyte/yugabyte-db/blob/master/src/postgres/third-party-extensions/documentdb/README.md

Create a database named 'quickStartDatabase' and a collection named 'quickStartCollection'.

```python
quickStartDatabase = client["quickStartDatabase"]
quickStartCollection = quickStartDatabase.create_collection("quickStartCollection")
```

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

### yba ha get example

Source: https://github.com/yugabyte/yugabyte-db/blob/master/managed/yba-cli/docs/yba_ha_describe.md

Example command to get the HA configuration.

```bash
yba ha get
```

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

### Postgres-dependent test with #[pg_test]

Source: https://github.com/yugabyte/yugabyte-db/blob/master/src/postgres/third-party-extensions/pgrx/skills/cargo-pgrx/SKILL.md

Use #[pg_test] for functions that need Postgres symbols. This example runs SPI inside a live backend; cargo pgrx test starts Postgres and installs the extension.

```rust
#[pg_test]
fn spi_returns_value() {
    let val = Spi::get_one::<i64>("SELECT 42").unwrap();
    assert_eq!(val, Some(42));
}
```

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

### Start the application

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/develop/tutorials/build-apps/nodejs/cloud-ysql-node.md

Run the sample Node.js application.

```sh
$ node sample-app.js
```

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

### Example usage

Source: https://github.com/yugabyte/yugabyte-db/blob/master/managed/yba-cli/docs/yba_universe_support-bundle_list-components.md

Lists support bundle components for the current universe.

```bash
yba universe support-bundle list-components
```

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

### Build and install pg_hint_plan from source

Source: https://github.com/yugabyte/yugabyte-db/blob/master/src/postgres/third-party-extensions/pg_hint_plan/docs/installation.md

Run these commands at the top of the source tree to build and install the module. The PATH environment variable must point to a PostgreSQL set of binaries. The 'su' command switches to an appropriate user for installation.

```none
$ tar xzvf pg_hint_plan-1.x.x.tar.gz
$ cd pg_hint_plan-1.x.x
$ make
$ su
$ make install
```

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

### Run pg_duckdb Docker container with default settings

Source: https://github.com/yugabyte/yugabyte-db/blob/master/src/postgres/third-party-extensions/pg_duckdb/scripts/tpch/README.md

Starts a pg_duckdb Postgres container with MotherDuck token enabled. Use this for quick setup; for real benchmarks, tune settings as shown in the next example.

```bash
# Simply run this to enable motherduck:
docker run --rm -e POSTGRES_HOST_AUTH_METHOD=trust --network=host -d --name pgduck -e MOTHERDUCK_TOKEN \
    pgduckdb/pgduckdb:18-main
```

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

### Run the Docker Compose example

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/integrations/datahub.md

Starts the DataHub quickstart containers with YugabyteDB. After all containers are running, ingest demo data with ./datahub/docker/ingestion/ingestion.sh or access the UI at http://localhost:9002 (username: datahub, password: datahub).

```sh
docker compose -f docker-compose-without-neo4j.quickstart.yml up -d
```

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

### Create keyspace, table, and insert data for RETURNS AS STATUS example

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/api/ycql/batch.md

SQL commands to set up the keyspace and table used in the Python RETURNS AS STATUS example. Includes inserts and a select to show the initial data.

```sql
ycqlsh> create keyspace if not exists yb_demo;
ycqlsh> CREATE TABLE if not exists yb_demo.test_rs_batch(h int, r bigint, v1 int, v2 varchar, primary key (h, r));
ycqlsh> INSERT INTO yb_demo.test_rs_batch(h,r,v1,v2) VALUES (1,1,1,'a');
ycqlsh> INSERT INTO yb_demo.test_rs_batch(h,r,v2) VALUES (3,3,'b');
ycqlsh> select * from yb_demo.test_rs_batch;

 h | r | v1   | v2
---+---+------+----
 1 | 1 |    1 |  a
 3 | 3 | null |  b

(2 rows)
```

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

### QuickStartApp.js - Create table, insert data, and fetch data

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/develop/drivers-orms/nodejs/yugabyte-node-driver.md

This is the complete sample application for Step 3. It creates a connection using the @yugabytedb/pg client, creates an 'employee' table, inserts two rows, and fetches all rows. Replace the yburl connection string with your cluster credentials and SSL certificate if required.

```javascript
const pg = require('@yugabytedb/pg');

function createConnection(){
    const yburl = "postgresql://yugabyte:yugabyte@localhost:5433/yugabyte?loadBalance=true";
    const client = new pg.Client(yburl);
    client.connect();
    return client;
}

async function createTableAndInsertData(client){
    console.log("Connected to the YugabyteDB Cluster successfully.")
    await client.query("DROP TABLE IF EXISTS employee").catch((err)=>{
        console.log(err.stack);
    })
    await client.query("CREATE TABLE IF NOT EXISTS employee" +
                "  (id int primary key, name varchar, age int, language text)").then(() => {
                    console.log("Created table employee");
                }).catch((err) => {
                    console.log(err.stack);
                })

    var insert_emp1 = "INSERT INTO employee VALUES (1, 'John', 35, 'Java')"
    await client.query(insert_emp1).then(() => {
        console.log("Inserted Employee 1");
    }).catch((err)=>{
        console.log(err.stack);
    })
    var insert_emp2 = "INSERT INTO employee VALUES (2, 'Sam', 37, 'JavaScript')"
    await client.query(insert_emp2).then(() => {
        console.log("Inserted Employee 2");
    }).catch((err)=>{
        console.log(err.stack);
    })
}

async function fetchData(client){
    try {
        const res = await client.query("select * from employee")
        console.log("Employees Information:")
        for (let i = 0; i<res.rows.length; i++) {
          console.log(`${i+1}. name = ${res.rows[i].name}, age = ${res.rows[i].age}, language = ${res.rows[i].language}`)
        }
      } catch (err) {
        console.log(err.stack)
      }
}

(async () => {
    const client = createConnection();
    if(client){
        await createTableAndInsertData(client);
        await fetchData(client);
    }
})();
```

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

### Migration example: Oracle START WITH to PostgreSQL WHERE clause

Source: https://github.com/yugabyte/yugabyte-db/blob/master/src/postgres/third-party-extensions/orafce/doc/sql_migration/sql_migration04.md

This example shows the migration of a hierarchical query that specifies a start row using START WITH. In the PostgreSQL version, the START WITH condition is moved to the WHERE clause of the first subquery in the WITH RECURSIVE clause.

```sql
SELECT staff_id, name, manager_id 
 FROM staff_table 
 START WITH staff_id = '1001' 
 CONNECT BY PRIOR staff_id = manager_id;
```

```sql
WITH RECURSIVE staff_table_w( staff_id, 
 name, 
 manager_id ) AS 
 ( SELECT staff_id, name, manager_id 
       FROM staff_table 
       WHERE staff_id = '1001' 
     UNION ALL 
     SELECT n.staff_id, n.name, n.manager_id 
       FROM staff_table n, staff_table_w w 
       WHERE w.staff_id = n.manager_id ) 
 SELECT staff_id, name, manager_id 
 FROM staff_table_w;
```

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

### Start Docker service

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/integrations/ysql-loader.md

Start Docker on the migration computer after installation.

```shell
sudo systemctl start docker
```

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

### Setup for elaborate example: schema and type

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/api/ysql/user-defined-subprograms-and-anon-blocks/language-plpgsql-subprograms/plpgsql-syntax-and-semantics/exception-section.md

Connects to the sandbox database, drops and recreates schema 's', and creates a composite type 's.rec'.

```plpgsql
\c :db :u
drop schema if exists s cascade;
create schema s;
create type s.rec as(outcome text, a numeric, b text);
```

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

### get_leader_blacklist_completion example

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/admin/yb-admin.md

Example of getting the leader blacklist completion percentage.

```sh
./bin/yb-admin \
    --master_addresses ip1:7100,ip2:7100,ip3:7100 \
    get_leader_blacklist_completion
```

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

### Install async utility

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/develop/drivers-orms/nodejs/ycql.md

Run this command to install the async utility, which is required for the sample application.

```sh
$ npm install --save async
```

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

### yba ha replication start example

Source: https://github.com/yugabyte/yugabyte-db/blob/master/managed/yba-cli/docs/yba_ha_replication_start.md

Example command that starts periodic backup replication with a 60-second frequency. Replace <config-uuid> with the actual HA configuration UUID.

```bash
yba ha replication start --uuid <config-uuid> --frequency-ms 60000
```

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

### Setup Table and Indexes

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/api/ycql/explain.md

Creates the keyspace, table, and two indexes (most_watched_by_year and best_rated) used in the EXPLAIN examples. The table is created with transactions enabled.

```CQL
cqlsh> CREATE KEYSPACE IF NOT EXISTS imdb;
cqlsh> CREATE TABLE IF NOT EXISTS imdb.movie_stats (
           movie_name text,
           movie_genre text,
           user_name text,
           user_rank int,
           last_watched timestamp,
           PRIMARY KEY (movie_genre, movie_name, user_name)
    ) WITH transactions = { 'enabled' : true };
cqlsh> CREATE INDEX IF NOT EXISTS most_watched_by_year
      ON imdb.movie_stats((movie_genre, last_watched), movie_name, user_name)
      INCLUDE(user_rank);
cqlsh> CREATE INDEX IF NOT EXISTS best_rated
      ON imdb.movie_stats((user_rank, movie_genre), movie_name, user_name)
      INCLUDE(last_watched);
```

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

### Install sequelize-yugabytedb and set up project

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/develop/drivers-orms/nodejs/sequelize.md

Commands to create a new directory, initialize a package.json, install the sequelize-yugabytedb package, and create an empty example.js file.

```sh
mkdir nodejs-quickstart-example && cd nodejs-quickstart-example
```

```sh
echo {} > package.json
```

```sh
npm install sequelize-yugabytedb
```

```sh
touch example.js
```

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

### Start Gremlin console

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/integrations/janusgraph.md

Starts the Gremlin console from the JanusGraph installation directory.

```sh
$ ./bin/gremlin.sh
```

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

### Example: Create support bundle with components and time range

Source: https://github.com/yugabyte/yugabyte-db/blob/master/managed/yba-cli/docs/yba_universe_support-bundle_create.md

Example command that creates a support bundle for the universe 'dkumar-cli' with specified components and a time range.

```bash
yba universe support-bundle -n dkumar-cli create \
  --components "UniverseLogs, OutputFiles, ErrorFiles, SystemLogs, PrometheusMetrics, ApplicationLogs" \
  --start-time 2025-04-17T00:00:00Z --end-time 2025-04-17T23:59:59Z
```

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

### Run Realtime Poll with npm install and npm start

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/integrations/hasura/hasura-sample-app.md

Commands to install dependencies and start the Realtime Poll application from its root directory. The app runs on http://localhost:3000.

```sh
$ npm install
$ npm start
```

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

### Install YBA with yba-ctl install

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/yugabyte-platform/install-yugabyte-platform/install-software/installer.md

Runs the full installation, which can take several minutes. It runs preflight checks first, then installs and waits for YBA to start.

```sh
sudo ./yba-ctl install
```

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

### Start the Application

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/develop/tutorials/build-apps/elixir/cloud-ysql-elixir.md

Start the application by calling SimpleApp.start.

```sh
SimpleApp.start
```

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

### Create example.js file

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/develop/drivers-orms/nodejs/prisma.md

Creates an empty example.js file.

```sh
touch example.js
```

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

### Change to YugabyteDB installation directory

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/develop/drivers-orms/python/yugabyte-psycopg3-reference.md

Navigate to the YugabyteDB installation directory before starting the cluster.

```sh
cd <path-to-yugabytedb-installation>

```

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

### main method: establish connection

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/develop/tutorials/build-apps/go/cloud-ysql-go.md

Builds the PostgreSQL connection string and opens a database connection using the lib/pq driver.

```go
psqlInfo := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s",
    host, port, dbUser, dbPassword, dbName)

if sslMode != "" {
    psqlInfo += fmt.Sprintf(" sslmode=%s", sslMode)

    if sslRootCert != "" {
        psqlInfo += fmt.Sprintf(" sslrootcert=%s", sslRootCert)
    }
}

db, err := sql.Open("postgres", psqlInfo)
```

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

### Navigate to YugabyteDB installation directory

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/develop/drivers-orms/java/yugabyte-jdbc-reference.md

Change to the directory where YugabyteDB is installed before starting the cluster.

```sh
cd <path-to-yugabytedb-installation>
```

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

### Initialize the project

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/develop/AI/azure-openai.md

Installs dependencies for the project and its frontend.

```sh
cd {project_dir}
npm i
cd frontend
npm i
```

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

### Install dependencies with npm

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/develop/drivers-orms/orms/nodejs/ysql-prisma.md

Installs the required npm packages for the Prisma example application.

```sh
$ npm install
```

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

### Run Atlas quick start script

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/integrations/atlas-ycql.md

Run bin/quick_start.py to add sample data. When prompted, enter admin for username and password. Output shows creation of sample types, entities, and lineage info.

```sh
bin/quick_start.py
```

```output
Creating sample types:
Created type [DB]
Created type [Table]
.
Created type [Table_Columns]
Created type [Table_StorageDesc]

Creating sample entities:
Created entity of type [DB], guid: f87936f1-d620-4f70-88c1-471f30e95c68
.
Created entity of type [LoadProcess], guid: c4c0e468-5af9-474f-acc1-088747ebf199
Created entity of type [LoadProcessExecution], guid: a03dd462-437d-42ee-b30f-dd0b8f1e9413
Created entity of type [LoadProcessExecution], guid: 2fe2e4c2-04ac-4c34-9a14-67436428949d

Sample DSL Queries:
query [from DB] returned [3] rows.
query [DB] returned [3] rows.
.
query [from DataSet] returned [10] rows.
query [from Process] returned [3] rows.

Sample Lineage Info:
loadSalesMonthly(LoadProcess) -> sales_fact_monthly_mv(Table)
time_dim(Table) -> loadSalesDaily(LoadProcess)
sales_fact_daily_mv(Table) -> loadSalesMonthly(LoadProcess)
sales_fact(Table) -> loadSalesDaily(LoadProcess)
loadSalesDaily(LoadProcess) -> sales_fact_daily_mv(Table)
Sample data added to Apache Atlas Server.
```

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

### Install GORM components

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/integrations/gorm.md

Installs the required GORM components using go get.

```shell
go get github.com/lib/pq
go get github.com/jinzhu/gorm
go get github.com/jinzhu/gorm/dialects/postgres
```

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

### Example: yba provider kubernetes list

Source: https://github.com/yugabyte/yugabyte-db/blob/master/managed/yba-cli/docs/yba_provider_kubernetes_list.md

Example command to list Kubernetes providers.

```bash
yba provider kubernetes list
```

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

### Start YSQL shell

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/benchmark/ycsb-jdbc.md

Command to start the YSQL shell for manual workload setup.

```sh
$ ./bin/ysqlsh -h <ip>
```

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

### \c examples: connect to a database

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/api/ysqlsh-meta-commands.md

Examples of the \c meta-command for establishing a new connection to a YugabyteDB server using positional syntax, conninfo strings, and a URI.

```plpgsql
=> \c mydb myuser host.dom 6432
=> \c service=foo
=> \c "host=localhost port=5432 dbname=mydb connect_timeout=10 sslmode=disable"
=> \c postgresql://tom@localhost/mydb?application_name=myapp
```

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

### Install pg gem with libpq paths

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/develop/drivers-orms/ysql-client-drivers.md

Run this command to install the pg driver when YugabyteDB is not installed locally. Replace <path-to-libpq> with the path to the libpq installation, for example /usr/local/opt.

```sh
gem install pg -- --with-pg-include=<path-to-libpq>/libpq/include --with-pg-lib=<path-to-libpq>/libpq/lib
```

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

### REGEXP_REPLACE examples

Source: https://github.com/yugabyte/yugabyte-db/blob/master/src/postgres/third-party-extensions/orafce/doc/orafce_documentation/Orafce_Documentation_05.md

Shows usage of REGEXP_REPLACE with different parameters: basic replacement, start position, and occurrence. The first example replaces all matches, the second starts at position 9, and the third replaces only the second occurrence.

```sql
SELECT regexp_replace('512.123.4567 612.123.4567', '([[:digit:]]{3})\.([[:digit:]]{3})\.([[:digit:]]{4})', '(\1) \2-\3') FROM DUAL;
        regexp_replace
-------------------------------
 (512) 123-4567 (612) 123-4567
(1 row)

```

```sql
SELECT oracle.REGEXP_REPLACE('number   your     street,    zipcode  town, FR', '( ){2,}', ' ', 9);
             regexp_replace             
----------------------------------------
 number   your street, zipcode town, FR
(1 row)

```

```sql
SELECT oracle.REGEXP_REPLACE('number   your     street,    zipcode  town, FR', '( ){2,}', ' ', 9, 2);
               regexp_replace                
---------------------------------------------
 number   your     street, zipcode  town, FR
(1 row)

```

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

### Start application server

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/integrations/wso2.md

Starts the application server from the IS_SAMPLES directory.

```shell
./IS-QSG/bin/app-server.sh
```

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

### Build the C application with gcc

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/develop/tutorials/build-apps/c/cloud-ysql-c.md

Compile the sample-app.c file using gcc, linking against the libpq library. Replace <path-to-libpq> with the actual path to your libpq installation, for example /usr/local/opt.

```sh
gcc sample-app.c -o sample-app -I<path-to-libpq>/libpq/include -L<path-to-libpq>/libpq/lib -lpq
```

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

### Example: download support bundle

Source: https://github.com/yugabyte/yugabyte-db/blob/master/managed/yba-cli/docs/yba_universe_support-bundle_download.md

Example command that downloads a support bundle by specifying the universe name and support bundle UUID.

```bash
yba universe support-bundle download --name <universe-name> --uuid <support-bundle-uuid>
```

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

### Example: get scope key value

Source: https://github.com/yugabyte/yugabyte-db/blob/master/managed/yba-cli/docs/yba_runtime-config_scope_key_get.md

Example usage of the command with a scope UUID and key name.

```bash
yba runtime-config scope key get --uuid <scope> --name <key-name>
```

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

### Create and run QuickStartApp.js

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/develop/drivers-orms/nodejs/postgres-node-driver.md

Sets up a Node.js application using the pg driver to connect to YugabyteDB, create an 'employee' table, insert a row, and query it. Run with 'node QuickStartApp.js' and expect the shown output.

```javascript
var pg = require('pg');
const async = require('async');
const assert = require('assert');

var connectionString = "postgres://postgres@localhost:5433/postgres";
var client = new pg.Client(connectionString);

async.series([
  function connect(next) {
    client.connect(next);
  },
  function createTable(next) {
    // The create table statement.
    const create_table = 'CREATE TABLE employee (id int PRIMARY KEY, ' +
                                                 'name varchar, ' +
                                                 'age int, ' +
                                                 'language varchar);';
    // Create the table.
    console.log('Creating table employee');
    client.query(create_table, next);
  },
  function insert(next) {
    // Create a variable with the insert statement.
    const insert = "INSERT INTO employee (id, name, age, language) " +
                                        "VALUES (1, 'John', 35, 'NodeJS');";
    // Insert a row with the employee data.
    console.log('Inserting row with: %s', insert)
    client.query(insert, next);
  },
  function select(next) {
    // Query the row for employee id 1 and print the results to the console.
    const select = 'SELECT name, age, language FROM employee WHERE id = 1;';
    client.query(select, function (err, result) {
      if (err) return next(err);
      var row = result.rows[0];
      console.log('Query for id=1 returned: name=%s, age=%d, language=%s',
                                            row.name, row.age, row.language);
      next();
    });
  }
], function (err) {
  if (err) {
    console.error('There was an error', err.message, err.stack);
  }
  console.log('Shutting down');
  client.end();
});
```

```javascript
node QuickStartApp.js
```

```output
Creating table employee
Inserting row with: INSERT INTO employee (id, name, age, language) VALUES (1, 'John', 35, 'NodeJS');
Query for id=1 returned: name=John, age=35, language=NodeJS
Shutting down
```

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

### Run provision_instance.py with flags

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/yugabyte-platform/configure-yugabyte-platform/on-premises-script.md

Example command to provision a node using the legacy assisted manual provisioning script. Set flags for password prompt, IP, mount points, node agent installation, API token, YBA URL, node name, instance type, and zone name. Expect a password prompt after execution.

```bash
/opt/yugabyte/yugaware/data/provision/9cf26f3b-4c7c-451a-880d-593f2f76efce/provision_instance.py \
    --ask_password \
    --ip 10.9.116.65 \
    --mount_points /data \
    --install_node_agent \
    --api_token 999bc9db-ddfb-9fec-a33d-4f8f9fd88db7 \
    --yba_url https://10.98.0.40:9000 \
    --node_name onprem_node1 \
    --instance_type c5.large \
    --zone_name us-west-2a
```

```output
Executing provision now for instance with IP 10.9.116.65...
SUDO password:
```

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

### Install Go Redis driver with go get

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/yedis/develop/client-drivers/yedis/go.md

Run this command to install the go-redis/redis driver for Go.

```sh
$ go get github.com/go-redis/redis
```

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

### Initialize a Go module for the application

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/develop/drivers-orms/go/yb-pgx.md

Run these commands to create a new directory and initialize a Go module named 'hello' before installing the driver package.

```sh
mkdir yb-pgx
cd yb-pgx
go mod init hello
```

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

### Install missing npm modules

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/contribute/docs/docs-build.md

If you get an error about missing modules, try running `npm install`.

```bash
npm install
```

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

### Install Python and SELinux package

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/yugabyte-platform/prepare/server-nodes-software/_index.md

Example commands to install Python 3.8 and the SELinux package using yum and pip, then set up symlinks and verify the installation.

```sh
sudo yum install python38
sudo pip3.8 install selinux
sudo ln -s /usr/bin/python3.8 /usr/bin/python
sudo rm /usr/bin/python3
sudo ln -s /usr/bin/python3.8 /usr/bin/python3
python3 -c "import selinux; import sys; print(sys.version)"
```

```output
> 3.8.19 (main, Sep 11 2024, 00:00:00)
> [GCC 11.5.0 20240719 (Red Hat 11.5.0-2)]
```

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

### yba runtime-config key-info list example

Source: https://github.com/yugabyte/yugabyte-db/blob/master/managed/yba-cli/docs/yba_runtime-config_key-info_list.md

Example command to list runtime configuration key info.

```bash
yba runtime-config key-info list
```

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

### Example: Download client certificate with name and username

Source: https://github.com/yugabyte/yugabyte-db/blob/master/managed/yba-cli/docs/yba_eit_hashicorp-vault_download_client.md

Example command that downloads a client certificate by specifying the configuration name and username.

```bash
yba eit hashicorp-vault download client --name <config-name> --username <username>
```

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

### Re-run xcode-select --install

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/contribute/docs/docs-build.md

Re-run `xcode-select --install` if you get an error about missing command-line tools.

```bash
xcode-select --install
```

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

### get_change_data_stream_info Example

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/admin/yb-admin.md

Example command to get info for a CDC DB stream. The response includes table_info and namespace_id.

```sh
./bin/yb-admin \
    --master_addresses 127.0.0.1:7100 \
    get_change_data_stream_info d540f5e4890c4d3b812933cbfd703ed3
```

```output
CDC DB Stream Info:
table_info {
  stream_id: "d540f5e4890c4d3b812933cbfd703ed3"
  table_id: "000033e1000030008000000000004000"
}
namespace_id: "000033e1000030008000000000000000"
```

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

### Run the Node.js example

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/develop/drivers-orms/nodejs/yugabyte-pg-reference.md

Executes the example.js file to create connections and display the load balancing map.

```sh
node example.js
```

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

### Install dependencies and start Jupyter notebook

Source: https://github.com/yugabyte/yugabyte-db/blob/master/src/postgres/third-party-extensions/postgresql_anonymizer/docs/how-to/README.md

Install required Python packages and launch Jupyter notebook to run the workshop.

```bash
pip install -r requirements.txt
jupyter notebook
```

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

### Run the C application

Source: https://github.com/yugabyte/yugabyte-db/blob/master/docs/content/stable/develop/tutorials/build-apps/c/cloud-ysql-c.md

Start the compiled sample-app executable. The expected output shows successful connection, table creation, account selection, and a transfer operation.

```sh
$ ./sample-app
```
Tokens:
Raw