Update README.md

README.md

@@ -14,48 +14,136 @@ Each crawl, we generate a Host Index, which aggregates information about each we
 information is aggregated from the Common Crawl [columnar index](https://commoncrawl.org/blog/index-to-warc-files-and-urls-in-columnar-format),
 [web graph](https://commoncrawl.org/web-graphs), and [raw crawler logs](https://data.commoncrawl.org).
 
+
 ## Quickstart
 
-### Using duckdb:
+The dataset is Hive-partitioned on `crawl` (`data/crawl=CC-MAIN-2025-18/*.parquet`). Open the whole
+dataset once, then filter with `WHERE crawl = '...'`: because `crawl` is a partition key, the query
+engine only reads the files for the crawls you ask for.
+
+### Using DuckDB
 
-DuckDB can [read directly from Huggingface](https://huggingface.co/docs/hub/en/datasets-duckdb):
+DuckDB can [read directly from Hugging Face](https://huggingface.co/docs/hub/en/datasets-duckdb).
+Create a view over every crawl once per session:
 
 ```sql
 $ duckdb
-D FROM 'hf://datasets/commoncrawl/host-index-testing-v2/data/crawl=CC-MAIN-2025-18/*.parquet' LIMIT 3;
-┌─────────────────────┬─────────────┬────────────────┬────────────┬────────────────┬───┬───────────────────┬─────────────────┬───────────┬───────────────────┬─────────────────┐
-│ nutch_unfetched_pct │ fetch_other │ fetch_200_lote │ nutch_gone │ nutch_gone_pct │ … │ fetch_notModified │ nutch_redirPerm │ fetch_200 │ nutch_notModified │      crawl      │
-│        int8         │    int64    │     int64      │   int64    │      int8      │   │       int64       │      int64      │   int64   │       int64       │     varchar     │
-├─────────────────────┼─────────────┼────────────────┼────────────┼────────────────┼───┼───────────────────┼─────────────────┼───────────┼───────────────────┼─────────────────┤
-│                   0 │           0 │              0 │          3 │              7 │ … │                 0 │               0 │        18 │                 0 │ CC-MAIN-2025-18 │
-│                   6 │           0 │              8 │          0 │              0 │ … │                 0 │               0 │        10 │                41 │ CC-MAIN-2025-18 │
-│                  80 │           0 │              0 │          8 │             17 │ … │                 0 │               0 │         0 │                 0 │ CC-MAIN-2025-18 │
-├─────────────────────┴─────────────┴────────────────┴────────────┴────────────────┴───┴───────────────────┴─────────────────┴───────────┴───────────────────┴─────────────────┤
-│ 3 rows                                                                                                                                                 43 columns (10 shown) │
-└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
-D SELECT surt_host_name FROM 'hf://datasets/commoncrawl/host-index-testing-v2/data/crawl=CC-MAIN-2025-18/*.parquet' LIMIT 3;
-┌──────────────────────┐
-│    surt_host_name    │
-│       varchar        │
-├──────────────────────┤
-│ ae,ebury             │
-│ be,echappeeduhainaut │
-│ au,com,echolaw       │
-└──────────────────────┘
+D CREATE VIEW ccindex AS
+    SELECT * FROM read_parquet(
+        'hf://datasets/commoncrawl/host-index-testing-v2/data/**/*.parquet',
+        hive_partitioning = true,   -- exposes the `crawl` directory as a column
+        union_by_name = true        -- tolerates the schema differences between some crawls
+    );
+```
+
+This `CREATE VIEW` is slow (minutes, not seconds): DuckDB lists every file under `data/` through
+the Hugging Face API and, because of `union_by_name`, reads the footer of each one to build the
+merged schema. You pay this once per session. To make it faster, narrow the glob to the crawls you
+need (e.g. `data/crawl=CC-MAIN-2025-*/*.parquet`), or drop `union_by_name` and stick to columns
+that exist in every crawl.
+
+Then run as many queries as you like against it. Always filter on `crawl`, and on
+`url_host_tld` when you can — both prune the amount of data read.
+
+Which crawls are available:
+
+```sql
+D SELECT DISTINCT crawl FROM ccindex ORDER BY crawl;
+```
+
+A single crawl:
+
+```sql
+D SELECT surt_host_name, fetch_200, hcrank10
+  FROM ccindex
+  WHERE crawl = 'CC-MAIN-2025-18'
+  LIMIT 3;
+```
+
+Several crawls — crawl names sort chronologically, so range comparisons work too:
+
+```sql
+D SELECT crawl, count(*) AS hosts, sum(fetch_200) AS pages_200
+  FROM ccindex
+  WHERE crawl IN ('CC-MAIN-2025-13', 'CC-MAIN-2025-18')
+  GROUP BY crawl ORDER BY crawl;
+
+D SELECT crawl, count(*) FROM ccindex
+  WHERE crawl >= 'CC-MAIN-2025-01'
+  GROUP BY crawl ORDER BY crawl;
 ```
 
-### Using Hugging Face `datasets` library:
+The crawl history of one host, across every crawl:
 
-"Streaming" mode (`streaming=True`) is recommended (see [the `datasets` docs](https://huggingface.co/docs/datasets/v4.4.1/en/stream)). This avoids the need to download all of the parquet files up-front.
+```sql
+D SELECT crawl, fetch_200, fetch_3xx, fetch_4xx, fetch_redirPerm, nutch_unfetched_pct, hcrank10
+  FROM ccindex
+  WHERE url_host_tld = 'org' AND surt_host_name = 'org,commoncrawl'
+  ORDER BY crawl;
+```
+
+Popular hosts in a crawl with mostly non-English content:
+
+```sql
+D SELECT surt_host_name, hcrank10, fetch_200, fetch_200_lote_pct
+  FROM ccindex
+  WHERE crawl = 'CC-MAIN-2025-18' AND fetch_200 >= 100 AND fetch_200_lote_pct > 50
+  ORDER BY hcrank10 DESC
+  LIMIT 20;
+```
+
+Notes:
+- The view re-lists the files on every query. If you will hammer one crawl, materialize it
+  instead: `CREATE TABLE c2025_18 AS SELECT * FROM ccindex WHERE crawl = 'CC-MAIN-2025-18';`
+- If your DuckDB does not auto-load `httpfs`, run `INSTALL httpfs; LOAD httpfs;` first.
+
+### Using pyarrow
+
+`pyarrow.dataset` understands the Hive partitioning natively and pushes the `crawl` filter down to
+the file listing:
+
+```python
+import pyarrow.dataset as ds
+from huggingface_hub import HfFileSystem
+
+fs = HfFileSystem()
+ccindex = ds.dataset(
+    "datasets/commoncrawl/host-index-testing-v2/data",
+    filesystem=fs, format="parquet", partitioning="hive",
+)
+
+crawl = ds.field("crawl")
+tld = ds.field("url_host_tld")
+
+# one crawl, one TLD
+gov = ccindex.to_table(filter=(crawl == "CC-MAIN-2025-18") & (tld == "gov"))
+
+# one host across all crawls
+history = ccindex.to_table(
+    filter=(tld == "org") & (ds.field("surt_host_name") == "org,commoncrawl"),
+    columns=["crawl", "fetch_200", "fetch_3xx", "fetch_redirPerm", "hcrank10"],
+).sort_by("crawl")
+```
+
+Pass `columns=` whenever you can: Parquet is columnar, so unread columns cost nothing.
+
+### Using the Hugging Face `datasets` library
+
+"Streaming" mode (`streaming=True`) avoids downloading all of the parquet files up-front (see
+[the `datasets` docs](https://huggingface.co/docs/datasets/v4.4.1/en/stream)). Point `data_dir`
+at one crawl's partition; note that the `crawl` column comes from the directory name, so it does
+not appear in rows loaded this way.
 
 ```python
 >>> from datasets import load_dataset
->>> ds = load_dataset("commoncrawl/host-index-testing-v2", data_dir="data/crawl=CC-MAIN-2025-18", split="train", streaming=True)
-Resolving data files: 100%|████████████| 30/30 [00:00<00:00, 43614.95it/s]
+>>> ds = load_dataset("commoncrawl/host-index-testing-v2",
+...                   data_dir="data/crawl=CC-MAIN-2025-18", split="train", streaming=True)
 >>> print(next(iter(ds)))
-{'nutch_unfetched_pct': 0, 'fetch_other': 0, 'fetch_200_lote': 0, 'nutch_gone': 3, 'nutch_gone_pct': 7, 'robots_gone': 0, 'robots_5xx': 0, 'hcrank10': 3.446, 'warc_record_length_median': 32867, 'hcrank': 11908759.0, 'nutch_fetched': 42, 'nutch_notModified_pct': 0, 'robots_4xx': 0, 'nutch_redirTemp': 0, 'fetch_redirPerm': 2, 'fetch_4xx': 0, 'url_host_tld': 'ae', 'nutch_fetched_pct': 93, 'robots_notModified': 0, 'robots_other': 0, 'nutch_redirTemp_pct': 0, 'fetch_200_lote_pct': 0, 'nutch_numRecords': 45, 'robots_3xx': 0, 'robots_redirTemp': 0, 'warc_record_length_av': 31769, 'url_host_registered_domain': 'ebury.ae', 'surt_host_name': 'ae,ebury', 'nutch_redirPerm_pct': 0, 'fetch_redirTemp': 0, 'robots_200': 3, 'fetch_3xx': 0, 'fetch_5xx': 0, 'nutch_unfetched': 0, 'prank': 4.73550733982247e-09, 'fetch_gone': 0, 'prank10': 0.0, 'robots_redirPerm': 1, 'fetch_notModified': 0, 'nutch_redirPerm': 0, 'fetch_200': 18, 'nutch_notModified': 0}
+{'nutch_unfetched_pct': 0, 'fetch_other': 0, ...}
 ```
 
+For multi-crawl work, prefer DuckDB or pyarrow above.
+
 ## Use Cases
 
 ### Example questions this index can answer