Chdb Sql

chdb SQL — ClickHouse in Your Python Process

Run ClickHouse SQL directly in Python — no server needed. Query local files, remote databases, and cloud storage with full ClickHouse SQL power.

pip install chdb

Decision Tree: Pick the Right API

1. One-off query on files or databases → chdb.query()
2. Multi-step analysis with tables      → Session
3. DB-API 2.0 connection                → chdb.connect()
4. Pandas-style DataFrame operations    → Use chdb-datastore skill instead

chdb.query() — One Line, Any Data

import chdb

chdb.query("SELECT * FROM file('data.parquet', Parquet) WHERE price > 100 LIMIT 10")       # local files
chdb.query("SELECT * FROM mysql('db:3306', 'shop', 'orders', 'root', 'pass')")              # databases
chdb.query("SELECT * FROM s3('s3://bucket/data.parquet', NOSIGN) LIMIT 10")                 # cloud storage
chdb.query("SELECT * FROM deltaLake('s3://bucket/delta/table', NOSIGN) LIMIT 10")           # data lakes

# Cross-source join
chdb.query("""
    SELECT u.name, o.amount FROM mysql('db:3306', 'crm', 'users', 'root', 'pass') AS u
    JOIN file('orders.parquet', Parquet) AS o ON u.id = o.user_id ORDER BY o.amount DESC
""")

data = {"name": ["Alice", "Bob"], "score": [95, 87]}
chdb.query("SELECT * FROM Python(data) ORDER BY score DESC")                                # Python data
df = chdb.query("SELECT * FROM numbers(10)", "DataFrame")                                   # output formats
chdb.query("SELECT toDate({d:String}) + number FROM numbers({n:UInt64})",
    "DataFrame", params={"d": "2025-01-01", "n": 30})                                      # parametrized

Table functions → table-functions.md | SQL functions → sql-functions.md | Full API → api-reference.md

Session — Stateful Analysis Pipelines

from chdb import session as chs
sess = chs.Session("./analytics_db")   # persistent; Session() for in-memory

sess.query("CREATE TABLE users ENGINE=MergeTree() ORDER BY id AS SELECT * FROM mysql('db:3306','crm','users','root','pass')")
sess.query("CREATE TABLE events ENGINE=MergeTree() ORDER BY (ts,user_id) AS SELECT * FROM s3('s3://logs/events/*.parquet',NOSIGN)")
sess.query("""
    SELECT u.country, count() AS cnt, uniqExact(e.user_id) AS users
    FROM events e JOIN users u ON e.user_id = u.id
    WHERE e.ts >= today() - 7 GROUP BY u.country ORDER BY cnt DESC
""", "Pretty").show()
sess.close()

Connection API (DB-API 2.0)

from chdb import dbapi
conn = dbapi.connect()
cur = conn.cursor()
cur.execute("SELECT * FROM file('data.parquet', Parquet) WHERE value > 100")
print(cur.fetchall())
cur.close()
conn.close()

Troubleshooting

References

• API Reference — query/Session/connect signatures
• Table Functions — All ClickHouse table functions
• SQL Functions — Commonly used SQL functions
• Examples — 9 runnable examples with expected output
• Official Docs

Note: This skill teaches how to use chdb SQL.

For pandas-style operations, use the chdb-datastore skill.

For contributing to chdb source code, see CLAUDE.md in the project root.

chdb SQL Examples

All examples are self-contained and runnable.

Expected output is shown in comments.

Table of Contents

1. Query Any File 2. Cross-Source SQL Joins 3. Session: Build Analytical Tables 4. Python Data as SQL Table 5. Parametrized Queries 6. Window Functions 7. User-Defined Functions (UDF) 8. Streaming Large Results 9. Common Errors & Fixes

---

1. Query Any File

import chdb

# Parquet
result = chdb.query("""
    SELECT country, count() AS cnt
    FROM file('users.parquet', Parquet)
    GROUP BY country
    ORDER BY cnt DESC
    LIMIT 10
""", "Pretty")
result.show()
# Expected: top 10 countries by user count, formatted table

# CSV
df = chdb.query("""
    SELECT * FROM file('sales.csv', CSVWithNames)
    WHERE revenue > 10000
    ORDER BY revenue DESC
""", "DataFrame")
print(df)
# Expected: pandas DataFrame with high-revenue rows

# JSON Lines
chdb.query("""
    SELECT * FROM file('events.jsonl', JSONEachRow)
    WHERE event_type = 'purchase'
""").show()

# Glob pattern — query all matching files
df = chdb.query("""
    SELECT level, count() AS cnt
    FROM file('logs/2024-*.parquet', Parquet)
    GROUP BY level
    ORDER BY cnt DESC
""", "DataFrame")
print(df)
# Expected:
#     level    cnt
# 0   INFO   45230
# 1   WARN    3210
# 2  ERROR     890

---

2. Cross-Source SQL Joins

import chdb

# MySQL + Parquet join
chdb.query("""
    SELECT u.name, u.email, o.product, o.amount
    FROM mysql('db:3306', 'crm', 'users', 'root', 'pass') AS u
    JOIN file('orders.parquet', Parquet) AS o ON u.id = o.user_id
    WHERE o.amount > 100
    ORDER BY o.amount DESC
    LIMIT 20
""", "Pretty").show()

# S3 + PostgreSQL join
df = chdb.query("""
    SELECT e.event_type, p.country, count() AS cnt
    FROM s3('s3://bucket/events.parquet', 'KEY', 'SECRET', 'Parquet') AS e
    JOIN postgresql('pg:5432', 'users', 'profiles', 'user', 'pass') AS p
        ON e.user_id = p.id
    GROUP BY e.event_type, p.country
    ORDER BY cnt DESC
""", "DataFrame")
print(df)

# ClickHouse + local CSV
chdb.query("""
    SELECT r.host, l.status_code, count() AS requests
    FROM remote('ch:9000', 'logs', 'access_log', 'default', '') AS r
    JOIN file('server_config.csv', CSVWithNames) AS l ON r.host = l.hostname
    GROUP BY r.host, l.status_code
    ORDER BY requests DESC
""").show()

---

3. Session: Build Analytical Tables

from chdb import session as chs

sess = chs.Session("./analytics_db")

# Ingest from multiple external sources into local tables
sess.query("""
    CREATE TABLE users ENGINE = MergeTree() ORDER BY id AS
    SELECT * FROM mysql('db:3306', 'crm', 'users', 'root', 'pass')
""")

sess.query("""
    CREATE TABLE events ENGINE = MergeTree() ORDER BY (ts, user_id) AS
    SELECT * FROM s3('s3://logs/events/*.parquet', NOSIGN)
""")

# Analyze locally — fast iterative queries
result = sess.query("""
    SELECT
        u.country,
        e.event_type,
        count() AS cnt,
        uniqExact(e.user_id) AS unique_users
    FROM events e
    JOIN users u ON e.user_id = u.id
    WHERE e.ts >= today() - 7
    GROUP BY u.country, e.event_type
    ORDER BY cnt DESC
    LIMIT 20
""", "Pretty")
result.show()
# Expected: formatted table with country, event_type, count, unique users

# Check table contents
sess.query("SELECT count() FROM users").show()
sess.query("SELECT count() FROM events").show()

sess.close()

---

4. Python Data as SQL Table

import chdb
import pandas as pd

# Query a Python dict directly in SQL
scores = {"student": ["Alice", "Bob", "Carol"], "math": [95, 87, 92], "science": [88, 91, 85]}
chdb.query("SELECT student, math + science AS total FROM Python(scores) ORDER BY total DESC").show()
# Expected:
# Alice,183
# Bob,178
# Carol,177

# Query a pandas DataFrame in SQL
users_df = pd.DataFrame({"id": [1, 2, 3], "name": ["Alice", "Bob", "Carol"]})
chdb.query("""
    SELECT p.name, o.product, o.amount
    FROM Python(users_df) AS p
    JOIN file('orders.parquet', Parquet) AS o ON p.id = o.user_id
    ORDER BY o.amount DESC
""").show()

# Use Python data for parametrized lookups
allowed_ids = {"id": [1, 3, 5, 7, 9]}
df = chdb.query("""
    SELECT * FROM file('data.parquet', Parquet)
    WHERE id IN (SELECT id FROM Python(allowed_ids))
""", "DataFrame")
print(df)

---

5. Parametrized Queries

import chdb

# Date range generation
result = chdb.query(
    """
    SELECT
        toDate({start:String}) + number AS date,
        rand() % 1000 AS value
    FROM numbers({days:UInt64})
    """,
    "DataFrame",
    params={"start": "2025-01-01", "days": 30})
print(result)
# Expected: DataFrame with 30 rows, date column from 2025-01-01 to 2025-01-30

# Filtering with parameters
result = chdb.query(
    """
    SELECT * FROM file('events.parquet', Parquet)
    WHERE event_type = {event:String}
      AND created_at >= {since:String}
    ORDER BY created_at DESC
    LIMIT {limit:UInt64}
    """,
    "DataFrame",
    params={"event": "purchase", "since": "2025-01-01", "limit": 100})
print(result)

---

6. Window Functions

import chdb

# Ranking within groups
chdb.query("""
    SELECT
        department,
        name,
        salary,
        rank() OVER (PARTITION BY department ORDER BY salary DESC) AS dept_rank,
        salary - avg(salary) OVER (PARTITION BY department) AS diff_from_avg
    FROM file('employees.parquet', Parquet)
    ORDER BY department, dept_rank
""", "Pretty").show()
# Expected: employees ranked within each department

# Running totals and moving averages
df = chdb.query("""
    SELECT
        date,
        revenue,
        sum(revenue) OVER (ORDER BY date) AS cumulative_revenue,
        avg(revenue) OVER (
            ORDER BY date
            ROWS BETWEEN 6 PRECEDING AND CURRENT ROW
        ) AS rolling_7d_avg
    FROM file('daily_sales.csv', CSVWithNames)
    ORDER BY date
""", "DataFrame")
print(df)
# Expected: daily sales with cumulative and 7-day rolling average

# Top-N per group
df = chdb.query("""
    SELECT * FROM (
        SELECT
            category,
            product,
            sales,
            row_number() OVER (PARTITION BY category ORDER BY sales DESC) AS rn
        FROM file('products.parquet', Parquet)
    ) WHERE rn <= 3
    ORDER BY category, rn
""", "DataFrame")
print(df)
# Expected: top 3 products per category by sales

---

7. User-Defined Functions (UDF)

from chdb.udf import chdb_udf
import chdb

@chdb_udf()
def fahrenheit_to_celsius(f):
    return (f - 32) * 5.0 / 9.0

result = chdb.query("""
    SELECT
        city,
        temp_f,
        fahrenheit_to_celsius(temp_f) AS temp_c
    FROM file('weather.csv', CSVWithNames)
    ORDER BY temp_c DESC
    LIMIT 10
""", "DataFrame")
print(result)

@chdb_udf()
def classify_age(age):
    if age < 18:
        return "minor"
    elif age < 65:
        return "adult"
    else:
        return "senior"

chdb.query("""
    SELECT classify_age(age) AS group, count() AS cnt
    FROM file('users.parquet', Parquet)
    GROUP BY group
    ORDER BY cnt DESC
""", "Pretty").show()

---

8. Streaming Large Results

from chdb import session as chs

sess = chs.Session()

# Stream results in chunks for memory efficiency
iterator = sess.send_query(
    "SELECT * FROM numbers(10000000)",
    format="CSV")

row_count = 0
for chunk in iterator:
    row_count += chunk.count(b'\n')

print(f"Total rows streamed: {row_count}")
# Expected: Total rows streamed: 10000000

sess.close()

---

9. Common Errors & Fixes

File not found

import chdb

# Error:
chdb.query("SELECT * FROM file('missing.parquet', Parquet)")
# → DB::Exception: FILE_NOT_FOUND

# Fix: verify the file path
import os
print(os.path.exists("missing.parquet"))  # → False
# Use absolute path or check current working directory
chdb.query("SELECT * FROM file('/absolute/path/to/data.parquet', Parquet)")

Wrong table function name

# Error: function name is case-sensitive for data lake functions
chdb.query("SELECT * FROM deltalake('s3://bucket/table', NOSIGN)")
# → DB::Exception: Unknown table function deltalake

# Fix: use camelCase
chdb.query("SELECT * FROM deltaLake('s3://bucket/table', NOSIGN)")

Database connection refused

# Error: missing port or wrong host format
chdb.query("SELECT * FROM mysql('db', 'shop', 'orders', 'root', 'pass')")
# → Connection refused

# Fix: include port in host string
chdb.query("SELECT * FROM mysql('db:3306', 'shop', 'orders', 'root', 'pass')")

Wrong output format

import chdb

# Error: format name is case-sensitive
df = chdb.query("SELECT 1", "dataframe")
# → might not return expected type

# Fix: use exact format name
df = chdb.query("SELECT 1", "DataFrame")  # capital D, capital F

Debugging queries

import chdb

# Use Pretty format to quickly inspect results
chdb.query("SELECT * FROM file('data.parquet', Parquet) LIMIT 5", "Pretty").show()

# Check column types
chdb.query("""
    SELECT name, toTypeName(name) AS name_type, toTypeName(value) AS value_type
    FROM file('data.parquet', Parquet)
    LIMIT 1
""", "Pretty").show()

# Explain query execution plan
chdb.query("EXPLAIN SELECT * FROM file('data.parquet', Parquet) WHERE x > 100").show()

chdb SQL

Agent skill for using chdb's SQL API — run ClickHouse SQL directly in Python without a server.

Installation

npx skills add clickhouse/agent-skills

What's Included

Trigger Phrases

This skill activates when you:

• "Query this Parquet/CSV file with SQL"
• "Use chdb to run a query"
• "Join MySQL and S3 data with SQL"
• "Create a ClickHouse session"
• "Use ClickHouse table functions"
• "Write a parametrized query"

Related

• chdb-datastore — For pandas-style DataFrame operations, use the chdb-datastore skill instead
• clickhouse-best-practices — For ClickHouse schema/query optimization

Documentation

• chdb docs
• chdb GitHub

chdb SQL API Reference

Complete signatures for the SQL-oriented chdb APIs.

Table of Contents

• chdb.query()
• Session
• Connection (DB-API 2.0)
• Output Formats
• Parametrized Queries
• Streaming Queries
• Progress Callback
• User-Defined Functions (UDF)
• AI-Assisted SQL

---

chdb.query()

chdb.query(sql, output_format="CSV", path="", udf_path="", params=None)

Returns: Result object with:

import chdb

result = chdb.query("SELECT 1 + 1 AS answer")
result.show()       # prints: 2
print(result.data())  # "2\n"

df = chdb.query("SELECT * FROM numbers(10)", "DataFrame")
print(df)  # pandas DataFrame

---

Session

from chdb import session as chs

sess = chs.Session()                    # in-memory (no persistence)
sess = chs.Session("./mydb")            # persistent to disk

from chdb import session as chs

sess = chs.Session("./analytics")

sess.query("CREATE TABLE t1 (id UInt64, name String) ENGINE = MergeTree() ORDER BY id")
sess.query("INSERT INTO t1 VALUES (1, 'Alice'), (2, 'Bob')")
result = sess.query("SELECT * FROM t1", "Pretty")
result.show()

sess.close()

Key differences from `chdb.query()`:

• Session maintains state: tables, databases, and settings persist across calls
• Persistent sessions (path="./dir") survive process restarts
• In-memory sessions (path=":memory:") are discarded on close

---

Connection (DB-API 2.0)

from chdb import dbapi

conn = dbapi.connect()    # or: dbapi.connect(path="./mydb")

from chdb import dbapi

conn = dbapi.connect()
cur = conn.cursor()
cur.execute("SELECT number, number * 2 AS doubled FROM numbers(5)")
print(cur.fetchall())
# [(0, 0), (1, 2), (2, 4), (3, 6), (4, 8)]
cur.close()
conn.close()

---

Output Formats

import chdb

chdb.query("SELECT 1", "Pretty").show()            # formatted table
df = chdb.query("SELECT * FROM numbers(5)", "DataFrame")  # pandas DataFrame
arrow = chdb.query("SELECT 1", "ArrowTable")        # pyarrow Table

---

Parametrized Queries

Use {name:Type} placeholders in SQL, and pass values via params:

import chdb

result = chdb.query(
    """
    SELECT toDate({start:String}) + number AS date, rand() % 1000 AS value
    FROM numbers({days:UInt64})
    """,
    "DataFrame",
    params={"start": "2025-01-01", "days": 30})
print(result)

Supported types: String, UInt8–UInt64, Int8–Int64, Float32, Float64, Date, DateTime.

---

Streaming Queries

For large results, use send_query on a Session to get an iterator:

from chdb import session as chs

sess = chs.Session()
iterator = sess.send_query("SELECT * FROM numbers(1000000)", format="CSV")
for chunk in iterator:
    print(chunk[:100])  # process each chunk
sess.close()

---

Progress Callback

Monitor query progress:

import chdb

def on_progress(progress):
    print(f"Rows: {progress.read_rows}, Bytes: {progress.read_bytes}")

chdb.query("SELECT * FROM numbers(10000000)", "CSV", progress_callback=on_progress)

---

User-Defined Functions (UDF)

Register Python functions as SQL UDFs using the @chdb_udf decorator:

from chdb.udf import chdb_udf

@chdb_udf()
def my_multiply(x, y):
    return x * y

import chdb
result = chdb.query("SELECT my_multiply(number, 10) FROM numbers(5)", "DataFrame")
print(result)

Limitations:

• UDFs execute in-process, not distributed
• Arguments and return values must be scalar types
• Performance may be lower than native ClickHouse functions for large datasets

---

AI-Assisted SQL

Generate SQL queries from natural language:

import chdb

sql = chdb.generate_sql("top 10 countries by revenue from orders.parquet")
print(sql)
# SELECT country, sum(revenue) AS total_revenue
# FROM file('orders.parquet', Parquet)
# GROUP BY country
# ORDER BY total_revenue DESC
# LIMIT 10

result = chdb.ask("What are the top products by sales?", data="sales.parquet")
print(result)

Note: These features require an LLM API key configured via environment variables.

ClickHouse SQL Functions Quick Reference

Commonly used SQL functions available in chdb.

For the full list, see ClickHouse documentation.

Table of Contents

• Aggregate Functions
• String Functions
• Date & Time Functions
• Type Conversion
• Conditional Functions
• Array Functions
• JSON Functions
• Window Functions

---

Aggregate Functions

---

String Functions

---

Date & Time Functions

Date units for dateDiff/dateAdd/dateSub: 'second', 'minute', 'hour', 'day', 'week', 'month', 'quarter', 'year'.

---

Type Conversion

---

Conditional Functions

---

Array Functions

---

JSON Functions

Nested access: Use path syntax: JSONExtractString(data, 'user', 'address', 'city')

---

Window Functions

Window functions compute values across a set of rows related to the current row.

Syntax

function() OVER (
    [PARTITION BY col1, col2, ...]
    [ORDER BY col1 [ASC|DESC], ...]
    [ROWS|RANGE BETWEEN ... AND ...]
)

Ranking Functions

SELECT name, dept, salary,
    row_number() OVER (PARTITION BY dept ORDER BY salary DESC) AS rn,
    rank() OVER (ORDER BY salary DESC) AS overall_rank
FROM employees

Value Functions

SELECT date, revenue,
    lag(revenue, 1, 0) OVER (ORDER BY date) AS prev_revenue,
    revenue - lag(revenue, 1, 0) OVER (ORDER BY date) AS daily_change
FROM daily_sales

Aggregate as Window

SELECT date, revenue,
    sum(revenue) OVER (ORDER BY date) AS cumulative,
    avg(revenue) OVER (ORDER BY date ROWS BETWEEN 6 PRECEDING AND CURRENT ROW) AS rolling_7d
FROM daily_sales

ClickHouse Table Functions for chdb

Table functions let you query external data sources directly in SQL.

Use them with chdb.query() or inside a Session.

Table of Contents

• File Sources
• Cloud Storage
• Databases
• Data Lakes
• Utility Functions

---

File Sources

file()

Query local files. Format is auto-detected from extension or specified explicitly.

SELECT * FROM file('data.parquet', Parquet)
SELECT * FROM file('data.csv', CSVWithNames)
SELECT * FROM file('events.jsonl', JSONEachRow)
SELECT * FROM file('logs/*.parquet', Parquet)              -- glob pattern
SELECT * FROM file('data/2024-*/events.csv', CSVWithNames) -- nested glob

Parameters: file(path [, format [, structure [, compression]]])

Supported formats: Parquet, CSVWithNames, CSV, TSVWithNames, JSONEachRow, JSON, Arrow, ORC, Avro, XMLWithNames.

Supported compression: auto-detected from extension (.gz, .zst, .bz2, .xz, .lz4).

---

Cloud Storage

s3()

-- Public (no auth)
SELECT * FROM s3('s3://bucket/path.parquet', NOSIGN)

-- With credentials
SELECT * FROM s3('s3://bucket/path.parquet', 'ACCESS_KEY', 'SECRET_KEY', 'Parquet')

-- Glob pattern
SELECT * FROM s3('s3://bucket/logs/2024-*.parquet', 'KEY', 'SECRET', 'Parquet')

Parameters: s3(url [, NOSIGN | access_key, secret_key] [, format [, structure [, compression]]])

gcs()

SELECT * FROM gcs('gs://bucket/data.parquet', NOSIGN)
SELECT * FROM gcs('gs://bucket/data.parquet', 'HMAC_KEY', 'HMAC_SECRET', 'Parquet')

Parameters: Same as s3().

azureBlobStorage()

SELECT * FROM azureBlobStorage(
    'DefaultEndpointsProtocol=https;AccountName=...;AccountKey=...',
    'container', 'path/data.parquet', 'Parquet')

Parameters: azureBlobStorage(connection_string, container, path [, format [, structure [, compression]]])

hdfs()

SELECT * FROM hdfs('hdfs://namenode:9000/warehouse/data.parquet', 'Parquet')
SELECT * FROM hdfs('hdfs://namenode:9000/logs/*.parquet', 'Parquet')

Parameters: hdfs(uri [, format [, structure [, compression]]])

---

Databases

mysql()

SELECT * FROM mysql('host:3306', 'database', 'table', 'user', 'password')

-- With WHERE pushdown
SELECT * FROM mysql('db:3306', 'shop', 'orders', 'root', 'pass')
WHERE status = 'shipped' AND amount > 100

Parameters: mysql(host:port, database, table, user, password)

Note: Port is part of the host string (e.g., 'db:3306'), not a separate parameter.

postgresql()

SELECT * FROM postgresql('host:5432', 'database', 'table', 'user', 'password')

SELECT * FROM postgresql('pg:5432', 'analytics', 'events', 'analyst', 'pass')
ORDER BY created_at DESC LIMIT 100

Parameters: postgresql(host:port, database, table, user, password)

remote() / remoteSecure()

Query a remote ClickHouse server:

SELECT * FROM remote('host:9000', 'database', 'table', 'user', 'password')
SELECT * FROM remoteSecure('host:9440', 'database', 'table', 'user', 'password')

Parameters: remote(host:port, database, table [, user [, password]])

mongodb()

SELECT * FROM mongodb('host:27017', 'database', 'collection', 'user', 'password')

Parameters: mongodb(host:port, database, collection, user, password)

sqlite()

SELECT * FROM sqlite('/path/to/database.db', 'table_name')

Parameters: sqlite(database_path, table)

---

Data Lakes

iceberg()

SELECT * FROM iceberg('s3://bucket/iceberg/table', 'ACCESS_KEY', 'SECRET_KEY')
SELECT * FROM iceberg('s3://bucket/iceberg/table', NOSIGN)

Parameters: iceberg(url [, NOSIGN | access_key, secret_key] [, format])

deltaLake()

SELECT * FROM deltaLake('s3://bucket/delta/table', 'ACCESS_KEY', 'SECRET_KEY')
SELECT * FROM deltaLake('s3://bucket/delta/table', NOSIGN)

Parameters: deltaLake(url [, NOSIGN | access_key, secret_key])

Note: Function name is deltaLake (camelCase), not deltalake.

hudi()

SELECT * FROM hudi('s3://bucket/hudi/table', 'ACCESS_KEY', 'SECRET_KEY')
SELECT * FROM hudi('s3://bucket/hudi/table', NOSIGN)

Parameters: hudi(url [, NOSIGN | access_key, secret_key])

---

Utility Functions

numbers()

Generate a sequence of numbers (useful for testing and date generation):

SELECT * FROM numbers(100)              -- 0 to 99
SELECT * FROM numbers(10, 100)          -- 10 to 109
SELECT toDate('2025-01-01') + number AS date FROM numbers(365)  -- date range

Parameters: numbers([offset,] count)

Python()

Use a Python dict or DataFrame as a SQL table:

import chdb

data = {"name": ["Alice", "Bob"], "score": [95, 87]}
chdb.query("SELECT * FROM Python(data) ORDER BY score DESC")

import pandas as pd
df = pd.DataFrame({"id": [1, 2, 3], "value": [10, 20, 30]})
chdb.query("SELECT * FROM Python(df) WHERE value > 15")

Note: The Python variable must be in scope when the query executes.

url()

Query data from an HTTP/HTTPS URL:

SELECT * FROM url('https://example.com/data.csv', CSVWithNames)
SELECT * FROM url('https://api.example.com/data.json', JSONEachRow)

Parameters: url(url, format [, structure])