For cloud Parquet data: zero download, query directly, fetch only needed columns — 10-50x faster.
For cloud CSV/JSON data: skip manual download, one SQL query — perfect for small-to-medium files.

INSTALL httpfs; -- One-time installation
LOAD httpfs; -- Required per session

-- Query rating distribution from TMDB movie dataset
SELECT 
 genre,
 ROUND(AVG(vote_average), 2) AS avg_rating,
 ROUND(AVG(vote_count), 0) AS avg_votes,
 COUNT(*) AS movie_count
FROM read_parquet(
 'https://huggingface.co/datasets/TMDB/tmdb-movie-metadata/resolve/main/data/movies.parquet'
)
WHERE vote_count > 50
GROUP BY genre
ORDER BY avg_rating DESC
LIMIT 10;

-- Analyze public event data directly from GitHub
SELECT 
 strftime(date, '%Y-%m') AS month,
 COUNT(*) AS event_count,
 COUNT(DISTINCT repo_name) AS repos
FROM read_csv_auto(
 'https://raw.githubusercontent.com/example/public-data/main/events.csv'
)
WHERE date >= '2026-01-01'
GROUP BY month
ORDER BY month;

-- Query a date range of all Parquet files on S3
SELECT 
 region,
 SUM(revenue) AS total_revenue,
 COUNT(DISTINCT customer_id) AS customers
FROM read_parquet(
 'https://data-bucket.s3.amazonaws.com/sales/*/2026/05/*/*.parquet'
)
WHERE amount > 0
GROUP BY region
ORDER BY total_revenue DESC;

#!/usr/bin/env python3
"""
DuckDB Remote File Query Demo
Query a HuggingFace remote Parquet dataset and export results
Prerequisites: pip install duckdb
"""

import duckdb
import time

def main():
 # Connect to in-memory database
 con = duckdb.connect()
 
 # Enable httpfs extension
 con.execute("INSTALL httpfs")
 con.execute("LOAD httpfs")
 
 # Optional: configure httpfs parameters
 con.execute("SET httpfs_retry_count = 3")
 con.execute("SET httpfs_timeout = 30")
 
 # Remote Parquet URL (HuggingFace TMDB movie data)
 remote_url = (
 "https://huggingface.co/datasets/TMDB/"
 "tmdb-movie-metadata/resolve/main/data/movies.parquet"
 )
 
 print(f"🔍 Querying remote: {remote_url}")
 print(f"⏳ Transferring only needed columns (not the whole file)...\n")
 
 start = time.time()
 
 # Query: DuckDB fetches only requested columns via Range Requests
 result = con.execute(f"""
 SELECT 
 title,
 vote_average,
 vote_count,
 release_date,
 genres
 FROM read_parquet('{remote_url}')
 WHERE vote_count > 100
 AND vote_average > 7.0
 ORDER BY vote_average DESC
 LIMIT 20
 """).fetchdf()
 
 elapsed = time.time() - start
 
 print(f"✅ Query completed in {elapsed:.2f}s")
 print(f"📊 {len(result)} rows returned\n")
 
 # Display results
 print("=" * 80)
 print(f"{'Rank':<4} {'Title':<40} {'Rating':<6} {'Votes':<8} {'Genre'}")
 print("-" * 80)
 for i, row in result.iterrows():
 title = str(row['title'])[:38] + '..' if len(str(row['title'])) > 38 else row['title']
 genres = str(row['genres'])[:30] if row['genres'] else 'N/A'
 print(f"{i+1:<4} {title:<40} {row['vote_average']:<6.1f} {row['vote_count']:<8} {genres}")
 
 # Export to local CSV
 output_path = "top_movies.csv"
 con.execute(f"""
 COPY (
 SELECT * FROM read_parquet('{remote_url}')
 WHERE vote_count > 100 AND vote_average > 7.0
 ORDER BY vote_average DESC
 LIMIT 20
 ) TO '{output_path}' (HEADER, DELIMITER ',')
 """)
 print(f"\n💾 Results exported: {output_path}")
 
 # Query dataset statistics (uses Parquet metadata, near-zero transfer)
 stats = con.execute(f"""
 SELECT 
 COUNT(*) AS total_movies,
 ROUND(AVG(vote_average), 2) AS avg_rating,
 ROUND(AVG(vote_count), 0) AS avg_vote_count,
 MIN(release_date) AS earliest,
 MAX(release_date) AS latest
 FROM read_parquet('{remote_url}')
 """).fetchone()
 
 print(f"\n📈 Dataset Overview (metadata query)")
 print(f" Total movies: {stats[0]:,}")
 print(f" Average rating: {stats[1]}")
 print(f" Average votes: {stats[2]:,.0f}")
 print(f" Date range: {stats[3]} ~ {stats[4]}")
 
 con.close()

if __name__ == "__main__":
 main()

pip install duckdb pandas
python3 duckdb_remote_query.py

# Launch DuckDB CLI
duckdb

# In the CLI
INSTALL httpfs;
LOAD httpfs;

SELECT title, vote_average, vote_count
FROM read_parquet('https://huggingface.co/datasets/TMDB/tmdb-movie-metadata/resolve/main/data/movies.parquet')
WHERE vote_count > 1000
ORDER BY vote_average DESC
LIMIT 10;

-- Set retry count (for unstable networks)
SET httpfs_retry_count = 5;

-- Set request timeout (seconds)
SET httpfs_timeout = 60;

-- Configure S3-compatible storage (MinIO, Alibaba OSS, etc.)
SET s3_region = 'us-east-1';
SET s3_access_key_id = '...';
SET s3_secret_access_key = '...';
SET s3_endpoint = 'https://my-minio-server.com';

-- Materialize remote data into a local table
CREATE TABLE local_movies AS
SELECT * FROM read_parquet('https://.../movies.parquet')
WHERE year >= 2020;

-- Now query locally at lightning speed
SELECT genre, COUNT(*) FROM local_movies GROUP BY genre;

-- Remote Parquet JOIN local CSV
SELECT 
 r.region,
 r.revenue,
 l.store_name
FROM read_parquet('https://s3-bucket/revenue/*.parquet') r
JOIN read_csv_auto('local_stores.csv') l
 ON r.store_id = l.store_id
WHERE r.date >= '2026-01-01';

-- AWS S3 (requires credentials)
SELECT * FROM read_parquet('s3://my-bucket/sales/*.parquet');

-- MinIO / Alibaba OSS / Tencent COS
SELECT * FROM read_parquet('s3://my-bucket/data/*.parquet');