QuestDB

https://questdb.com/docs
Admin
QuestDB is a high-performance, open-source time-series database that offers category-leading...
Tokens:1,333,615
Snippets:10,740
Trust Score:9.5
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Start minikube, install QuestDB chart, and check pods

Source: https://questdb.com/docs/deployment/kubernetes

Starts a local Kubernetes cluster with minikube, installs the QuestDB Helm chart, and lists the pods to verify the deployment. The expected output shows a pod named my-questdb-0 with status Running.

```bash
minikube start  
```

```bash
helm install my-questdb questdb/questdb  
```

```bash
kubectl get pods  
```

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

### Start a backup example

Source: https://questdb.com/docs/query/sql/backup

Starts a backup. The result is a single column backup_timestamp with the timestamp of the backup, e.g., 2024-08-24T12:34:56.789123Z.

```sql
BACKUP DATABASE;  
```

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

### Install and start QuestDB on GCP

Source: https://questdb.com/docs/deployment/gcp

Downloads QuestDB 10.0.1 and starts it with `/var/lib/questdb` as the QuestDB root directory. After starting, the Web Console is accessible at `http://<external-ip>:9000` and the REST API on port 9000.

```bash
wget https://github.com/questdb/questdb/releases/download/10.0.1/questdb-10.0.1-rt-linux-x86-64.tar.gz  
tar xzf questdb-10.0.1-rt-linux-x86-64.tar.gz  
cd questdb-10.0.1-rt-linux-x86-64/bin  
./questdb.sh start -d /var/lib/questdb  
./questdb.sh status -d /var/lib/questdb  

```

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

### Install QuestDB Windows service

Source: https://questdb.com/docs/configuration/overview

Installs the Windows QuestDB service, which will start automatically at startup.

```bash
questdb.exe install  
```

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

### Start the connector: create topic and run connect-standalone

Source: https://questdb.com/docs/connect/message-brokers/kafka

Commands to create the Kafka topic and start the connector in standalone mode. Run from the Kafka installation directory.

```bash
bin/kafka-topics.sh --create --if-not-exists --topic example-topic --bootstrap-server localhost:9092  
bin/connect-standalone.sh config/connect-standalone.properties config/questdb-connector.properties  

```

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

### Exact Versions of Installed Packages

Source: https://questdb.com/docs/integrations/data-processing/spark

Lists the exact versions of the installed packages used in the example. Useful for reproducing the environment.

```text
openjdk@11 11.0.12  
python@3.10 3.10.10_1  
scala 3.2.2  
apache-spark 3.3.2  

```

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

### Start with custom parameters

Source: https://questdb.com/docs/troubleshooting/profiling

Starts the profiler with custom agent parameters, overriding all defaults. The example profiles CPU events to /tmp/profile.jfr at 10ms intervals.

```bash
./questdb.sh start -p -- start,event=cpu,file=/tmp/profile.jfr,interval=10ms  

```

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

### Query data with Go using /exec

Source: https://questdb.com/docs/query/overview

Go example that constructs a URL for the /exec endpoint, sends a GET request, and logs the response body. Includes a checkErr helper that panics on error.

```go
package main

import (
  "fmt"
  "io/ioutil"
  "log"
  "net/http"
  "net/url"
)

func main() {
  u, err := url.Parse("http://localhost:9000")
  checkErr(err)

  u.Path += "exec"
  params := url.Values{}
  params.Add("query", "SELECT x FROM long_sequence(5);")
  u.RawQuery = params.Encode()
  url := fmt.Sprintf("%v", u)

  res, err := http.Get(url)
  checkErr(err)

  defer res.Body.Close()

  body, err := ioutil.ReadAll(res.Body)
  checkErr(err)

  log.Println(string(body))
}

func checkErr(err error) {
  if err != nil {
    panic(err)
  }
}
```

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

### docker-compose.yml for Redpanda quickstart

Source: https://questdb.com/docs/connect/message-brokers/redpanda

Docker Compose configuration to start a single Redpanda broker and the Redpanda Console web UI. Save this as docker-compose.yml and run 'docker compose up' to start the services.

```yaml
---  
version: "3.7"  
name: redpanda-quickstart  
networks:  
  redpanda_network:  
    driver: bridge  
volumes:  
  redpanda-0: null  
services:  
  redpanda-0:  
    command:  
      - redpanda  
      - start  
      - --kafka-addr  
      - internal://0.0.0.0:9092,external://0.0.0.0:19092  
      # use the internal addresses to connect to the Redpanda brokers'  
      # from inside the same Docker network.  
      #  
      # use the external addresses to connect to the Redpanda brokers'  
      # from outside the Docker network.  
      #  
      # address the broker advertises to clients that connect to the Kafka API.  
      - --advertise-kafka-addr  
      - internal://redpanda-0:9092,external://localhost:19092  
      - --pandaproxy-addr  
      - internal://0.0.0.0:8082,external://0.0.0.0:18082  
      # address the broker advertises to clients that connect to PandaProxy.  
      - --advertise-pandaproxy-addr  
      - internal://redpanda-0:8082,external://localhost:18082  
      - --schema-registry-addr  
      - internal://0.0.0.0:8081,external://0.0.0.0:18081  
      # Redpanda brokers use the RPC API to communicate with eachother internally.  
      - --rpc-addr  
      - redpanda-0:33145  
      - --advertise-rpc-addr  
      - redpanda-0:33145  
      # tells Seastar (the framework Redpanda uses under the hood) to use 1 core on the system.  
      - --smp 1  
      # the amount of memory to make available to Redpanda.  
      - --memory 1G  
      # the amount of memory that's left for the Seastar subsystem.  
      # For development purposes this is set to 0.  
      - --reserve-memory 0M  
      # Redpanda won't assume it has all of the provisioned CPU  
      # (to accommodate Docker resource limitations).  
      - --overprovisioned  
      # enable logs for debugging.  
      - --default-log-level=debug  
    image: docker.redpanda.com/vectorized/redpanda:v22.3.11  
    container_name: redpanda-0  
    volumes:  
      - redpanda-0:/var/lib/redpanda/data  
    networks:  
      - redpanda_network  
    ports:  
      - 18081:18081  
      - 18082:18082  
      - 19092:19092  
      - 19644:9644  
  console:  
    container_name: redpanda-console  
    image: docker.redpanda.com/vectorized/console:v2.1.1  
    networks:  
      - redpanda_network  
    entrypoint: /bin/sh  
    command: -c 'echo "$$CONSOLE_CONFIG_FILE" > /tmp/config.yml; /app/console'  
    environment:  
      CONFIG_FILEPATH: /tmp/config.yml  
      CONSOLE_CONFIG_FILE: |  
        kafka:  
          brokers: ["redpanda-0:9092"]  
          schemaRegistry:  
            enabled: true  
            urls: ["http://redpanda-0:8081"]  
        redpanda:  
          adminApi:  
            enabled: true  
            urls: ["http://redpanda-0:9644"]  
    ports:  
      - 8080:8080  
    depends_on:  
      - redpanda-0  

```

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

### Example configuration with table option

Source: https://questdb.com/docs/connect/message-brokers/flink

Example configuration for connecting to QuestDB running on localhost, specifying the target table 'orders'.

```sql
CREATE TABLE Orders (  
     order_number BIGINT,  
     price        BIGINT,  
     buyer        STRING  
 ) WITH (  
   'connector'='questdb',  
   'host'='localhost',  
   'table' = 'orders'  
);  
```

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

### lag() example: previous price and price change

Source: https://questdb.com/docs/query/functions/window-functions/reference

Example query using lag() to get the previous price for each symbol and the price from two rows back, with 0.0 as the default when the offset reaches the partition start.

```sql
SELECT  
    timestamp,  
    price,  
    lag(price) OVER (  
        PARTITION BY symbol  
        ORDER BY timestamp  
    ) AS previous_price,  
    lag(price, 2, 0.0) OVER (  
        PARTITION BY symbol  
        ORDER BY timestamp  
    ) AS price_two_rows_back  
FROM trades  
WHERE timestamp IN '$today';  

```

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

### Start Flink cluster

Source: https://questdb.com/docs/connect/message-brokers/flink

Starts the Flink cluster from the bin directory of the Flink installation.

```bash
./start-cluster.sh  
```

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

### Regular expression does NOT match example

Source: https://questdb.com/docs/query/sql/where

Example query filtering trades where symbol does not start with 'BTC'.

```sql
SELECT * FROM trades  
WHERE timestamp IN '$now-1h..$now'  
  AND symbol !~ '^BTC'  
LIMIT -3;  

```

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

### Start QuestDB (Windows)

Source: https://questdb.com/docs/configuration/overview

Starts QuestDB as a service on Windows with options for root directory, force redeploy, JAVA_HOME, and tag.

```bash
questdb.exe start [-d dir] [-f] [-j JAVA_HOME] [-t tag]  
```

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

### Example output from SHOW USER

Source: https://questdb.com/docs/security/rbac

Example output from SHOW USER showing auth_type and enabled columns.

```text
auth_type    enabled  
---------    -------  
Password     true  
JWK Token    false  
REST Token   true  

```

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

### Regular expression match example

Source: https://questdb.com/docs/query/sql/where

Example query filtering trades where symbol starts with 'BTC'.

```sql
SELECT * FROM trades  
WHERE timestamp IN '$now-1h..$now'  
  AND symbol ~ '^BTC'  
LIMIT -3;  

```

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

### Get session start times with first

Source: https://questdb.com/docs/cookbook/sql/time-series/session-windows

For each session, gets the timestamp and status at the beginning of that session.

```sql
SELECT first(timestamp) as ts, ...  
FROM global_sessions  
GROUP BY session  
```

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

### client.conf.string configuration examples

Source: https://questdb.com/docs/connect/message-brokers/kafka

Examples of client.conf.string configurations for different protocols and authentication methods. The password and token values are expanded from environment variables.

```text
# Minimal configuration  
client.conf.string=ws::addr=localhost:9000;  
  
# Basic authentication with the password from an environment variable  
client.conf.string=ws::addr=questdb.example.com:9000;username=admin;password=${QUESTDB_PASSWORD};  
  
# TLS with a bearer token (QuestDB Enterprise)  
client.conf.string=wss::addr=questdb.example.com:9000;token=${QUESTDB_TOKEN};  
  
# Multi-host failover (QuestDB Enterprise)  
client.conf.string=wss::addr=node-a:9000,node-b:9000;token=${QUESTDB_TOKEN};  

```

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

### GET /lifecycle response example

Source: https://questdb.com/docs/high-availability/failover

Example JSON response from GET /lifecycle showing the current role, switch-in-flight flag, readiness, and component states. The ready flag is false while any component is DEGRADED or FAILED.

```json
{  
  "capturedAtMicros": 1756380000123456,  
  "currentRole": "PRIMARY",  
  "switchInFlight": false,  
  "ready": true,  
  "components": [  
    {  
      "name": "engine",  
      "state": "READY",  
      "lastTransitionMicros": 1756379991204000,  
      "latestProgress": null,  
      "hardRequiredDependencies": ["factory-provider", "backup-restore"],  
      "softDependencies": []  
    },  
    {  
      "name": "replication",  
      "state": "READY",  
      "lastTransitionMicros": 1756379991650000,  
      "latestProgress": null,  
      "hardRequiredDependencies": ["engine"],  
      "softDependencies": []  
    }  
  ]  
}  

```

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

### questdb.sh start -p syntax

Source: https://questdb.com/docs/troubleshooting/profiling

Shows the full command syntax for starting QuestDB with continuous profiling, including options for directory, force overwrite, HUP signal handling, tag, and agent parameters.

```bash
./questdb.sh start -p [-d dir] [-f] [-n] [-t tag] [-- agent-params]  

```

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

### Start Flink SQL console

Source: https://questdb.com/docs/connect/message-brokers/flink

Starts the Flink SQL client from the bin directory of the Flink installation.

```bash
./sql-client.sh  
```

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

### Start with default settings

Source: https://questdb.com/docs/troubleshooting/profiling

Starts the profiler with default events (cpu,wall) and writes to the default profiles directory.

```bash
./questdb.sh start -p  

```

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

### Production example: TLS + token + multi-host

Source: https://questdb.com/docs/connect/clients/dotnet

Production example combining wss, token auth, multi-host failover, and a store-and-forward directory for ingestion, plus a query client configured to prefer a replica. The sender uses Sender.NewQwp with sf_dir and sender_id; the query client uses QueryClient.NewAsync with target=replica and failover options.

```csharp
// Ingestion — write to any writeable node.  
await using var sender = Sender.NewQwp(  
    "wss::addr=db-primary:9000,db-replica:9000;"  
    + "token=your_bearer_token;"  
    + "sf_dir=/var/lib/myapp/qdb-sf;"  
    + "sender_id=ingest-1;"  
    + "reconnect_max_duration_millis=300000;");  
  
// Querying — prefer a replica to offload the primary.  
await using var query = await QueryClient.NewAsync(  
    "wss::addr=db-primary:9000,db-replica:9000;"  
    + "token=your_bearer_token;"  
    + "target=replica;"  
    + "failover=on;failover_max_duration_ms=30000;");  

```

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

### pg_postmaster_start_time()

Source: https://questdb.com/docs/query/functions/date-time

Function to get the server start time.

```APIDOC
## pg_postmaster_start_time()

### Description
Returns the time when the server started.

### Method
Function

### Endpoint
`pg_postmaster_start_time()`

### Parameters
None

### Return Value
- **timestamp** - The time when the server started.

### Example
```sql
SELECT pg_postmaster_start_time();
```

| pg_postmaster_start_time |
|--------------------------|
| 2023-03-30T16:20:29.763961Z |
```

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

### Start QuestDB (Linux)

Source: https://questdb.com/docs/configuration/overview

Starts QuestDB as a service on Linux with options for root directory, force redeploy, no HUP response, and tag.

```bash
./questdb.sh start [-d dir] [-f] [-n] [-t tag]  
```

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

### Install QuestDB client and Polars

Source: https://questdb.com/docs/integrations/data-processing/polars

Install the QuestDB Python client, Polars, and pyarrow via pip. Required for Python examples.

```bash
python3 -m pip install -U questdb polars pyarrow  
```

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

### Install psycopg3 with pip

Source: https://questdb.com/docs/connect/compatibility/pgwire/overview

Install the psycopg3 client library using pip. This is required before running the Python example that uses the psycopg adapter.

```bash
python3 -m pip install "psycopg[binary]"  

```

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

### Create and query a view with SAMPLE BY

Source: https://questdb.com/docs/concepts/views

Shows creating a view with CREATE VIEW and a SAMPLE BY clause, then querying it like a table. The view aggregates trades data into hourly summaries.

```sql
-- Create a view  
CREATE VIEW hourly_summary AS (  
  SELECT ts, symbol, sum(quantity) as volume  
  FROM trades  
  SAMPLE BY 1h  
);  
  
-- Query the view like a table  
SELECT * FROM hourly_summary WHERE symbol = 'AAPL';  
```

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

### Get server start time with pg_postmaster_start_time

Source: https://questdb.com/docs/query/functions/date-time

Returns the server start time as a timestamp. The function takes no arguments and returns a timestamp value.

```sql
SELECT pg_postmaster_start_time();  

```

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

### All questdb.exe options

Source: https://questdb.com/docs/getting-started/quick-start

Shows all options for the Windows `questdb.exe` command. `install` installs the Windows service, `remove` removes it, `-d` sets the root directory, `-t` sets a service tag (default `questdb`), `-f` forces re-deploying the Web Console, and `-j` specifies a path to `JAVA_HOME` (Windows only).

```bash
questdb.exe [start|stop|status|install|remove] \
  [-d dir] [-f] [-j JAVA_HOME] [-t tag]  

```

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

### Install pgx v5 with go get

Source: https://questdb.com/docs/connect/compatibility/pgwire/go

Install the pgx v5 driver for Go using Go modules. This is the latest version as of the documentation.

```bash
# For the latest version (v5)  
go get github.com/jackc/pgx/v5  

```

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

### Download and start QuestDB on Azure VM

Source: https://questdb.com/docs/deployment/azure

These commands download QuestDB 10.0.1, extract the archive, change to the bin directory, and start the QuestDB server. After running them, access the Web Console at http://<your-vm-ip>:9000.

```bash
wget https://github.com/questdb/questdb/releases/download/10.0.1/questdb-10.0.1-rt-linux-x86-64.tar.gz  
tar xzf questdb-10.0.1-rt-linux-x86-64.tar.gz  
cd questdb-10.0.1-rt-linux-x86-64/bin  
./questdb.sh start  
```

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

### Install postgres client

Source: https://questdb.com/docs/connect/compatibility/pgwire/nodejs

Install the postgres client library for Node.js.

```bash
npm install postgres  
```

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

### Production example (TLS + token + multi-host)

Source: https://questdb.com/docs/connect/clients/dotnet

Shows a realistic Enterprise deployment combining wss, token auth, multi-host failover, and store-and-forward for ingestion and querying.

```APIDOC
## Production example (TLS + token + multi-host)

### Description
Shows a realistic Enterprise deployment combining wss, token auth, multi-host failover, and store-and-forward for ingestion and querying.

### Method
N/A (SDK usage)

### Endpoint
N/A

### Parameters
#### Connection String (Ingestion)
- **addr** (string) - Required - Comma-separated list of host:port for writeable nodes.
- **token** (string) - Required - Bearer token for authentication.
- **sf_dir** (string) - Optional - Directory for store-and-forward so unacked frames survive a sender restart.
- **sender_id** (string) - Optional - Identifier for the sender.
- **reconnect_max_duration_millis** (int) - Optional - Maximum duration for reconnection attempts.

#### Connection String (Querying)
- **addr** (string) - Required - Comma-separated list of host:port for nodes.
- **token** (string) - Required - Bearer token for authentication.
- **target** (string) - Optional - Preferred target node (e.g., `replica`).
- **failover** (string) - Optional - `on` or `off` to enable failover.
- **failover_max_duration_ms** (int) - Optional - Maximum duration for failover.

### Request Example
```csharp
// Ingestion — write to any writeable node.  
await using var sender = Sender.NewQwp(  
    "wss::addr=db-primary:9000,db-replica:9000;"  
    + "token=your_bearer_token;"  
    + "sf_dir=/var/lib/myapp/qdb-sf;"  
    + "sender_id=ingest-1;"  
    + "reconnect_max_duration_millis=300000;");  
  
// Querying — prefer a replica to offload the primary.  
await using var query = await QueryClient.NewAsync(  
    "wss::addr=db-primary:9000,db-replica:9000;"  
    + "token=your_bearer_token;"  
    + "target=replica;"  
    + "failover=on;failover_max_duration_ms=30000;");  
```

### Response
#### Success Response
- **sender** (Sender) - A configured Sender instance for ingestion.
- **query** (QueryClient) - A configured QueryClient instance for querying.

#### Response Example
N/A
```

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

### Full example: ingestion and querying with failover

Source: https://questdb.com/docs/connect/clients/dotnet

Full example combining multi-host ingest with Sender.NewQwp and a recreate-on-terminal query client pattern. Uses TLS + token auth, store-and-forward (sf_dir), and a connection listener. The query client must be disposed and rebuilt after terminal failures (failover budget exhausted, cancellation, AuthFailed, or QwpRoleMismatchException).

```csharp
using QuestDB;  
using QuestDB.Qwp.Query;  
using QuestDB.Senders;  
using QuestDB.Utils;  
  
const string ingestConnStr =  
    "wss::addr=db-primary:9000,db-replica:9000;"   // Enterprise: wss + multi-host  
    + "token=your_bearer_token;"                    // Enterprise: token auth  
    + "tls_verify=unsafe_off;"                      // test only!  
    + "sf_dir=/var/lib/myapp/qdb-sf;"               // disk-backed durability  
    + "sender_id=ingest-1;"                         // distinct per process  
    + "reconnect_max_duration_millis=300000;";  
  
const string queryConnStr =  
    "wss::addr=db-primary:9000,db-replica:9000;"  
    + "token=your_bearer_token;"  
    + "tls_verify=unsafe_off;"                      // test only!  
    + "target=replica;"                             // offload reads  
    + "failover=on;failover_max_attempts=8;"  
    + "failover_max_duration_ms=30000;";  
  
// ─── Ingestion ──────────────────────────────────────────────────────  
  
var ingestOptions = Sender.Configure(ingestConnStr);  
ingestOptions.error_handler = err =>  
    Console.Error.WriteLine(  
        $"batch rejected: category={err.Category} table={err.TableName} "  
        + $"fsn=[{err.FromFsn},{err.ToFsn}] msg={err.ServerMessage}");  
ingestOptions.ConnectionListener = new IngestListener();  
  
await using var sender = Sender.NewQwp(ingestOptions);  
  
for (var i = 0; i < 100; i++)  
{  
    await sender.Table("trades")  
        .Symbol("symbol", "ETH-USD")  
        .Symbol("side", i % 2 == 0 ? "buy" : "sell")  
        .Column("price", 2615.54 + i * 0.01)  
        .Column("amount", 0.001 * (i + 1))  
        .AtAsync(DateTime.UtcNow);  
}  
  
// Bound the publish on a known FSN, then drain remaining ACKs on dispose.  
long fsn = await sender.FlushAndGetSequenceAsync();  
await sender.AwaitAckedFsnAsync(fsn, TimeSpan.FromSeconds(10));  
  
// Connection events you may see in IngestListener.OnEvent:  
//   Connected db-primary:9000               — initial connection  
//   Disconnected db-primary:9000            — primary dropped  
//   EndpointAttemptFailed db-primary:9000   — retries during outage  
//   FailedOver db-replica:9000              — replica took over  
//  
// With sf_dir set, unacked frames are persisted to disk during the  
// outage and replayed once the new primary is reachable.  
  
  
// ─── Querying (recreate-on-terminal pattern) ────────────────────────  
  
// The QueryClient enters a terminal state once the failover budget is  
// exhausted (or on CancellationToken cancel, AuthFailed, or  
// QwpRoleMismatchException). The application must Dispose the dead  
// client and build a new one. This loop encodes that contract.  
  
IQwpQueryClient? client = null;  
  
while (true)  
{  
    if (client is null)  
    {  
        try  
        {  
            client = await QueryClient.NewAsync(queryConnStr);  
        }  
        catch (Exception ex)  
        {  
            Console.Error.WriteLine($"connect failed: {ex.Message}");  
            await Task.Delay(TimeSpan.FromSeconds(2));  
            continue;  
        }  
    }  
  
    try  
    {  
        // `trades` was auto-created by the ingest above, so its designated  
```

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

### substring with negative start example

Source: https://questdb.com/docs/query/functions/text

Shows the behavior of substring when the start argument is negative. For start=-5 and length=9, start+length=4, so the substring stops at position 3, resulting in 'Lor'.

```sql
SELECT substring('Lorem ipsum dolor sit amet', -5, 9)  
```

```text
substring  
---  
Lor  
```

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

### Install PostgreSQL Client

Source: https://questdb.com/docs/deployment/hetzner

Install the PostgreSQL client on the QuestDB server for checkpoint management during backups.

```bash
# Install PostgreSQL client  
questdb01$ apt update && apt install -y postgresql-client  

```

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

### Enable user example

Source: https://questdb.com/docs/query/sql/acl/alter-user

Enables the user account 'john'.

```sql
ALTER USER john ENABLE;  
```

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

### SHOW PARTITIONS FROM x (split partitions example)

Source: https://questdb.com/docs/query/sql/alter-table-squash-partitions

Displays partition split details for table x. The output shows two partitions for 2023-02-05 as a result of partition split.

```sql
SHOW PARTITIONS FROM x;  
```

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

### lead() example: next price

Source: https://questdb.com/docs/query/functions/window-functions/reference

Example query using lead() to get the next price for each symbol and the price from two rows ahead, with 0.0 as the default when the offset reaches the partition end.

```sql
SELECT  
    timestamp,  
    price,  
    lead(price) OVER (  
        PARTITION BY symbol  
        ORDER BY timestamp  
    ) AS next_price,  
    lead(price, 2, 0.0) OVER (  
        PARTITION BY symbol  
        ORDER BY timestamp  
    ) AS price_after_next  
FROM trades  
WHERE timestamp IN '$today';  

```

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

### Follow container logs to verify startup

Source: https://questdb.com/docs/integrations/other/mindsdb

Follows the container logs to verify that the APIs have started. The output shows the expected startup messages and ports.

```bash
docker logs -f qmdb  
...  
http API: starting...  
mysql API: starting...  
mongodb API: starting...  
...  
mongodb API: started on 47336  
mysql API: started on 47335  
http API: started on 47334  

```

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

### First price in partition with first_value()

Source: https://questdb.com/docs/query/functions/window-functions/reference

Example of first_value() to get the first price in each partition, and first_value() with IGNORE NULLS to get the first non-null price. Uses a window partitioned by symbol and ordered by timestamp.

```sql
SELECT  
    symbol,  
    price,  
    timestamp,  
    first_value(price) OVER (  
        PARTITION BY symbol  
        ORDER BY timestamp  
    ) AS first_price,  
    first_value(price) IGNORE NULLS OVER (  
        PARTITION BY symbol  
        ORDER BY timestamp  
    ) AS first_non_null_price  
FROM trades  
WHERE timestamp IN '$today';  
```

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

### Run the qmdb container

Source: https://questdb.com/docs/integrations/other/mindsdb

Starts the qmdb container with the required ports exposed. The container runs as user 'quest' and takes about 10 seconds to become responsive.

```bash
docker run --rm \  
    -p 8812:8812 \  
    -p 9009:9009 \  
    -p 9000:9000 \  
    -p 8888:8888 \  
    -p 47334:47334 \  
    -p 47335:47335 \  
    -d \  
    --name qmdb \  
    questdb/mindsdb:latest  

```

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

### LIKE query example

Source: https://questdb.com/docs/query/functions/pattern-matching

Example query using LIKE to filter rows where the symbol ends with '-USDT'. The query uses LATEST ON timestamp PARTITION BY symbol to get the latest trade per symbol.

```sql
SELECT * FROM trades  
WHERE symbol LIKE '%-USDT'  
LATEST ON timestamp PARTITION BY symbol;  

```
Tokens:
Raw