@@ -55,9 +55,14 @@ raw SQL condition.
 
 `stats` reports, for each column, the declared type, how many NULLs, how many
 distinct values, the minimum, the maximum and the most frequent values
-(`--top N`). `search` looks for a case-insensitive substring in every non-BLOB
-column of every table (`--table` restricts it, `--limit` stops early) and
-prints the table, column, rowid and value of each match.
+(`--top N`). Everything but the frequent values comes from a single pass over
+the table; on big tables use `--top 0` to skip them, `--columns` to analyse
+only some columns, or `--sample N` to work on a random sample of N rows (the
+output then says so). Likewise `tables --no-count` skips the row counts.
+
+`search` looks for a case-insensitive substring in every non-BLOB column of
+every table (`--table` restricts it, `--limit` stops early) and prints the
+table, column, rowid and value of each match. Each table is scanned once.
 
 ## Output options
 
 
@@ -309,12 +309,20 @@ def _split_list(value: str | None) -> list[str] | None:
 def tables(
     database: DatabaseArg,
     include_internal: AllOption = False,
+    count: Annotated[
+        bool,
+        typer.Option(
+            "--count/--no-count",
+            help="Count the rows of every table and view (--no-count is faster on big ones).",
+        ),
+    ] = True,
     *,
     options: OutputOptions,
 ) -> None:
     """List the tables and views of the database with their row counts."""
     with _reporting_errors(), open_database(database) as db:
-        emit(db.tables(include_internal=include_internal), options, empty="(no tables)")
+        result = db.tables(include_internal=include_internal, count=count)
+        emit(result, options, empty="(no tables)")
 
 
 @app.command()
@@ -439,14 +447,36 @@ def stats(
     database: DatabaseArg,
     table: TableArg,
     top: Annotated[
-        int, typer.Option("--top", min=0, help="How many frequent values to list per column.")
+        int,
+        typer.Option(
+            "--top",
+            min=0,
+            help="How many frequent values to list per column; 0 skips them, which is much "
+            "faster on big tables.",
+        ),
     ] = 3,
+    columns: Annotated[
+        str | None,
+        typer.Option("--columns", "-c", help="Comma-separated list of columns to analyse."),
+    ] = None,
+    sample: Annotated[
+        int | None,
+        typer.Option(
+            "--sample",
+            min=1,
+            help="Compute on a random sample of N rows instead of the whole table.",
+        ),
+    ] = None,
     *,
     options: OutputOptions,
 ) -> None:
     """Per-column statistics: nulls, distinct values, min, max and most frequent values."""
     with _reporting_errors(), open_database(database) as db:
-        emit(db.stats(table, top=top), options)
+        report = db.stats(table, top=top, columns=_split_list(columns) or None, sample=sample)
+        emit(report.result, options)
+        if report.sampled:
+            plural = "" if report.rows == 1 else "s"
+            typer.echo(f"computed on a random sample of {report.rows} row{plural}", err=True)
 
 
 @app.command()
 
@@ -23,6 +23,7 @@
     "ReadOnlyError",
     "ResultSet",
     "RowStream",
+    "StatsReport",
     "open_database",
     "plan_tree",
     "quote_identifier",
@@ -90,6 +91,14 @@ def collect(self) -> ResultSet:
         return ResultSet(columns=self.columns, rows=list(self.rows), rowcount=self.rowcount)
 
 
+class StatsReport(NamedTuple):
+    """Per-column statistics, plus how many rows they were computed on."""
+
+    result: ResultSet
+    rows: int
+    sampled: bool
+
+
 def _rows_of(cursor: sqlite3.Cursor) -> Iterator[tuple]:
     try:
         yield from cursor
@@ -271,13 +280,16 @@ def objects(self, *, include_internal: bool = False) -> list[tuple[str, str, str
         sql += " ORDER BY rowid"
         return [(kind, name, statement) for kind, name, statement in self.execute(sql).rows]
 
-    def tables(self, *, include_internal: bool = False) -> ResultSet:
-        """List tables and views together with their row counts."""
+    def tables(self, *, include_internal: bool = False, count: bool = True) -> ResultSet:
+        """List tables and views, with their row counts unless *count* is false."""
         sql = "SELECT type, name FROM sqlite_master WHERE type IN ('table', 'view')"
         if not include_internal:
             sql += " AND name NOT LIKE 'sqlite_%'"
         sql += " ORDER BY type, name"
-        rows = [(kind, name, self._count_rows(name)) for kind, name in self.execute(sql).rows]
+        objects = self.execute(sql).rows
+        if not count:
+            return ResultSet(columns=("type", "name"), rows=[tuple(row) for row in objects])
+        rows = [(kind, name, self._count_rows(name)) for kind, name in objects]
         return ResultSet(columns=("type", "name", "rows"), rows=rows)
 
     def _count_rows(self, name: str) -> int | str:
@@ -488,26 +500,99 @@ def stream_rows(
         query = f"SELECT {selection} {source}{order} LIMIT ? OFFSET ?"
         return self.stream(query, (-1 if limit is None else limit, offset))
 
-    def stats(self, table: str, *, top: int = 3) -> ResultSet:
-        """Per-column summary of *table*: nulls, distinct values, min, max, top values."""
-        q_table = quote_identifier(table)
-        rows = []
-        for _cid, name, declared, *_ in self.columns(table).rows:
-            q_col = quote_identifier(name)
-            nulls, distinct, minimum, maximum, min_type = self.execute(
-                f"SELECT COUNT(*) - COUNT({q_col}), COUNT(DISTINCT {q_col}),"
-                f" MIN({q_col}), MAX({q_col}), typeof(MIN({q_col})) FROM {q_table}"
-            ).rows[0]
-            frequent = self.execute(
-                f"SELECT quote({q_col}), COUNT(*) AS n FROM {q_table}"
-                f" WHERE {q_col} IS NOT NULL GROUP BY {q_col} ORDER BY n DESC, 1 LIMIT ?",
-                (top,),
-            ).rows
-            summary = ", ".join(f"{value} ({count})" for value, count in frequent)
-            rows.append((name, declared or min_type, nulls, distinct, minimum, maximum, summary))
-        return ResultSet(
-            columns=("column", "type", "nulls", "distinct", "min", "max", "top"), rows=rows
+    def stats(
+        self,
+        table: str,
+        *,
+        top: int = 3,
+        columns: Sequence[str] | None = None,
+        sample: int | None = None,
+    ) -> StatsReport:
+        """Per-column summary of *table*: nulls, distinct values, min, max, top values.
+
+        Nulls, distinct values, minimum and maximum of every column come from a
+        single pass over the table; the *top* most frequent values need one
+        ``GROUP BY`` per column, so ``top=0`` is much cheaper on big tables.
+        With *sample*, everything is computed on a random sample of that many
+        rows copied to a temporary table.
+        """
+        info = self.columns(table).rows
+        known = [row[1] for row in info]
+        declared = {row[1]: row[2] for row in info}
+        if columns is None:
+            selected = known
+        else:
+            selected = [self._resolve_column(table, name, known) for name in columns]
+        if sample is None:
+            return self._collect_stats(quote_identifier(table), selected, declared, top, False)
+        source = self._sample(table, selected, sample)
+        try:
+            return self._collect_stats(source, selected, declared, top, True)
+        finally:
+            self._connection.execute(f"DROP TABLE IF EXISTS {source}")
+
+    def _sample(self, table: str, columns: Sequence[str], size: int) -> str:
+        """Copy a random sample of *table* into a temporary table; return its name."""
+        selection = ", ".join(quote_identifier(name) for name in columns)
+        self._connection.execute(f"DROP TABLE IF EXISTS {_SAMPLE_TABLE}")
+        self._connection.execute(
+            f"CREATE TEMP TABLE {_SAMPLE_NAME} AS SELECT {selection}"
+            f" FROM {quote_identifier(table)} ORDER BY random() LIMIT ?",
+            (size,),
         )
+        return _SAMPLE_TABLE
+
+    def _collect_stats(
+        self,
+        source: str,
+        columns: Sequence[str],
+        declared: Mapping[str, str],
+        top: int,
+        sampled: bool,
+    ) -> StatsReport:
+        rows = []
+        examined = 0
+        for start in range(0, len(columns), _STATS_CHUNK):
+            chunk = columns[start : start + _STATS_CHUNK]
+            expressions = ["COUNT(*)"]
+            for name in chunk:
+                q_col = quote_identifier(name)
+                expressions += [
+                    f"COUNT({q_col})",
+                    f"COUNT(DISTINCT {q_col})",
+                    f"MIN({q_col})",
+                    f"MAX({q_col})",
+                    f"typeof(MIN({q_col}))",
+                ]
+            values = self.execute(f"SELECT {', '.join(expressions)} FROM {source}").rows[0]
+            examined = values[0]
+            for index, name in enumerate(chunk):
+                filled, distinct, minimum, maximum, min_type = values[1 + index * 5 : 6 + index * 5]
+                rows.append(
+                    (
+                        name,
+                        declared.get(name) or min_type,
+                        examined - filled,
+                        distinct,
+                        minimum,
+                        maximum,
+                        self._top_values(source, name, top),
+                    )
+                )
+        if not columns:
+            examined = self.execute(f"SELECT COUNT(*) FROM {source}").rows[0][0]
+        return StatsReport(ResultSet(columns=_STATS_COLUMNS, rows=rows), examined, sampled)
+
+    def _top_values(self, source: str, column: str, top: int) -> str:
+        if top <= 0:
+            return ""
+        q_col = quote_identifier(column)
+        frequent = self.execute(
+            f"SELECT quote({q_col}), COUNT(*) AS n FROM {source}"
+            f" WHERE {q_col} IS NOT NULL GROUP BY {q_col} ORDER BY n DESC, 1 LIMIT ?",
+            (top,),
+        ).rows
+        return ", ".join(f"{value} ({count})" for value, count in frequent)
 
     def search(
         self, text: str, *, tables: Sequence[str] | None = None, limit: int | None = None
@@ -608,3 +693,8 @@ def import_rows(
 
 
 _SEARCH_COLUMNS = ("table", "column", "rowid", "value")
+_STATS_COLUMNS = ("column", "type", "nulls", "distinct", "min", "max", "top")
+# Columns per aggregate query: five expressions each, well below SQLITE_MAX_COLUMN.
+_STATS_CHUNK = 100
+_SAMPLE_NAME = '"sqlitexplorer_sample"'
+_SAMPLE_TABLE = f"temp.{_SAMPLE_NAME}"
@@ -213,7 +213,7 @@ def _dot_command(
         elif command == ".indexes":
             emit(db.indexes(argument or None), options, empty="(no indexes)")
         elif command == ".stats":
-            emit(db.stats(_required(argument, command)), options)
+            emit(db.stats(_required(argument, command)).result, options)
         elif command == ".format":
             options.format = _parse_format(argument)
         elif command == ".null":
 
@@ -319,6 +319,25 @@ def test_stats_reports_per_column_summary(invoke: Callable, database: Path) -> N
     assert "age,INTEGER,1,2,12,30,12 (1)" in result.output
 
 
+def test_stats_columns_sample_and_no_top(invoke: Callable, database: Path) -> None:
+    result = invoke(
+        "stats", database, "users", "-c", "name,age", "--top", "0", "--sample", "2", "-f", "csv"
+    )
+    assert result.exit_code == 0
+    lines = result.stdout.splitlines()
+    assert lines[0] == "column,type,nulls,distinct,min,max,top"
+    assert [line.split(",")[0] for line in lines[1:]] == ["name", "age"]
+    assert all(line.endswith(",") for line in lines[1:])  # no top values
+    assert "computed on a random sample of 2 rows" in result.stderr
+
+
+def test_tables_no_count(invoke: Callable, database: Path) -> None:
+    result = invoke("tables", database, "--no-count", "-f", "csv")
+    assert result.exit_code == 0
+    assert result.stdout.splitlines()[0] == "type,name"
+    assert "table,users" in result.stdout
+
+
 def test_stats_unknown_table_fails(invoke: Callable, database: Path) -> None:
     result = invoke("stats", database, "nope")
     assert result.exit_code == 1
 
@@ -209,7 +209,10 @@ def test_rows_rejects_unknown_column(database: Path) -> None:
 
 def test_stats_reports_nulls_distinct_min_max_top(database: Path) -> None:
     with open_database(database) as db:
-        result = db.stats("users", top=2)
+        report = db.stats("users", top=2)
+    assert report.rows == 3
+    assert not report.sampled
+    result = report.result
     assert result.columns == ("column", "type", "nulls", "distinct", "min", "max", "top")
     by_column = {row[0]: row for row in result.rows}
     assert by_column["age"][1:6] == ("INTEGER", 1, 2, 12, 30)
@@ -222,12 +225,51 @@ def test_stats_on_view_falls_back_to_typeof_for_expressions(database: Path) -> N
     connection.execute("CREATE VIEW doubled AS SELECT name, age * 2 AS twice FROM users")
     connection.close()
     with open_database(database) as db:
-        adults = db.stats("adults")
-        doubled = db.stats("doubled")
+        adults = db.stats("adults").result
+        doubled = db.stats("doubled").result
     assert [(row[0], row[1]) for row in adults.rows] == [("name", "TEXT"), ("age", "INTEGER")]
     assert [(row[0], row[1]) for row in doubled.rows] == [("name", "TEXT"), ("twice", "integer")]
 
 
+def test_stats_columns_top_zero_and_sample(database: Path) -> None:
+    with open_database(database) as db:
+        subset = db.stats("users", columns=["AGE"], top=0)
+        assert [row[0] for row in subset.result.rows] == ["age"]
+        assert subset.result.rows[0][1:] == ("INTEGER", 1, 2, 12, 30, "")
+        sampled = db.stats("users", sample=2)
+        assert sampled.sampled
+        assert sampled.rows == 2
+        assert all(row[2] + row[3] <= 2 for row in sampled.result.rows)  # nulls + distinct
+        assert db.execute(
+            "SELECT COUNT(*) FROM sqlite_temp_master WHERE name = 'sqlitexplorer_sample'"
+        ).rows == [(0,)]  # the sample is dropped afterwards
+        with pytest.raises(ExplorerError, match="no such column in users: nope"):
+            db.stats("users", columns=["nope"])
+        assert db.stats("empty").rows == 0
+
+
+def test_stats_handles_hundreds_of_columns_in_one_pass(tmp_path: Path) -> None:
+    definition = ", ".join(f"c{index} INTEGER" for index in range(250))
+    path = make_database(
+        tmp_path / "wide.db",
+        f"CREATE TABLE wide ({definition}); INSERT INTO wide (c0, c249) VALUES (1, 2);",
+    )
+    with open_database(path) as db:
+        report = db.stats("wide", top=1)
+    assert len(report.result.rows) == 250
+    by_column = {row[0]: row for row in report.result.rows}
+    assert by_column["c0"][2:] == (0, 1, 1, 1, "1 (1)")
+    assert by_column["c1"][2:] == (1, 0, None, None, "")
+    assert by_column["c249"][5] == 2
+
+
+def test_tables_without_counts(database: Path) -> None:
+    with open_database(database) as db:
+        result = db.tables(count=False)
+    assert result.columns == ("type", "name")
+    assert ("table", "users") in result.rows
+
+
 def test_search_finds_text_in_any_table(relational_database: Path) -> None:
     with open_database(relational_database) as db:
         result = db.search("world")