"""Read-only SQLite page census and sampled column-size audit. The census reads interior B-tree pages and counts their leaf pointers. It excludes overflow pages, then reconciles its total with the file header. Column figures use sampled leaf records and are estimates of record bytes. """ from pathlib import Path import collections import json import random import sqlite3 import struct import time def varint(data, pos): value = 0 start = pos for _ in range(8): byte = data[pos] pos += 1 value = (value << 7) | (byte & 127) if byte < 128: return value, pos, pos - start value = (value << 8) | data[pos] return value, pos + 1, 9 def serial_bytes(serial): if serial < 12: return (0, 1, 2, 3, 4, 6, 8, 8, 0, 0, 0, 0)[serial] return (serial - 12) // 2 class Audit: def __init__(self, path): self.path = path self.file = path.open('rb', buffering=0) self.header = self.file.read(100) assert self.header[:16] == b'SQLite format 3\0' self.pagesize = struct.unpack_from('>H', self.header, 16)[0] if self.pagesize == 1: self.pagesize = 65536 self.usable = self.pagesize - self.header[20] self.page_count = struct.unpack_from('>I', self.header, 28)[0] self.free_pages = struct.unpack_from('>I', self.header, 36)[0] assert struct.unpack_from('>I', self.header, 52)[0] == 0, 'Unexpected auto-vacuum pointer maps' self.conn = sqlite3.connect(path.as_uri() + '?mode=ro&immutable=1', uri=True) self.conn.execute('PRAGMA cache_size=-8192') self.read_pages = 0 def page(self, number): assert 1 <= number <= self.page_count self.file.seek((number - 1) * self.pagesize) data = self.file.read(self.pagesize) assert len(data) == self.pagesize self.read_pages += 1 return data def census(self, root, seed): rng = random.Random(seed) leaf_sample = [] leaf_count = 0 interior_count = 0 def add_leaf(number): nonlocal leaf_count leaf_count += 1 if len(leaf_sample) < 128: leaf_sample.append(number) else: index = rng.randrange(leaf_count) if index < len(leaf_sample): leaf_sample[index] = number def visit(number, known_data=None): nonlocal interior_count data = known_data if known_data is not None else self.page(number) offset = 100 if number == 1 else 0 kind = data[offset] if kind in (10, 13): add_leaf(number) return assert kind in (2, 5), (number, kind) interior_count += 1 count = struct.unpack_from('>H', data, offset + 3)[0] children = [] for index in range(count): cell = struct.unpack_from('>H', data, offset + 12 + index * 2)[0] children.append(struct.unpack_from('>I', data, cell)[0]) children.append(struct.unpack_from('>I', data, offset + 8)[0]) child_data = self.page(children[0]) child_offset = 100 if children[0] == 1 else 0 child_kind = child_data[child_offset] if child_kind in (10, 13): expected = 10 if kind == 2 else 13 assert child_kind == expected for child in children: add_leaf(child) else: assert child_kind == kind visit(children[0], child_data) for child in children[1:]: visit(child) visit(root) return interior_count, leaf_count, sorted(leaf_sample) def sample_columns(self, name, leaves): columns = [row[1] for row in self.conn.execute('PRAGMA table_info("' + name.replace('"', '""') + '")')] stats = {column: {'payload_bytes': 0, 'serial_bytes': 0, 'nonnull': 0, 'present': 0} for column in columns} rows = 0 payload_total = 0 leaf_cells = 0 for number in leaves: data = self.page(number) offset = 100 if number == 1 else 0 assert data[offset] == 13, 'Expected a rowid table leaf' count = struct.unpack_from('>H', data, offset + 3)[0] leaf_cells += count for index in range(count): cell = struct.unpack_from('>H', data, offset + 8 + index * 2)[0] payload_size, pos, _ = varint(data, cell) _, pos, _ = varint(data, pos) payload_start = pos header_size, pos, _ = varint(data, pos) assert payload_start + header_size <= len(data), 'Record header extends off-page' serials = [] while pos < payload_start + header_size: serial, pos, serial_length = varint(data, pos) serials.append((serial, serial_length)) assert pos == payload_start + header_size assert len(serials) <= len(columns) assert header_size + sum(serial_bytes(serial) for serial, _ in serials) == payload_size for column, (serial, length) in zip(columns, serials): item = stats[column] item['payload_bytes'] += serial_bytes(serial) item['serial_bytes'] += length item['nonnull'] += serial != 0 item['present'] += 1 rows += 1 payload_total += payload_size for item in stats.values(): item['avg_record_bytes'] = (item['payload_bytes'] + item['serial_bytes']) / rows if rows else 0 item['nonnull_fraction'] = item['nonnull'] / rows if rows else 0 return {'sample_rows': rows, 'sample_leaf_pages': len(leaves), 'avg_rows_per_leaf': leaf_cells / len(leaves), 'avg_payload_bytes': payload_total / rows if rows else 0, 'columns': stats} def run(self): objects = [('table', 'sqlite_schema', 'sqlite_schema', 1)] objects += list(self.conn.execute("SELECT type,name,tbl_name,rootpage FROM sqlite_master WHERE type IN ('table','index') AND rootpage > 0 ORDER BY type,name")) results = [] for object_type, name, table, root in objects: interior, leaves, sample = self.census(root, name) row = {'type': object_type, 'name': name, 'table': table, 'btree_pages': interior + leaves, 'interior_pages': interior, 'leaf_pages': leaves, 'btree_bytes': (interior + leaves) * self.pagesize} if object_type == 'table' and name != 'sqlite_schema': row['column_sample'] = self.sample_columns(name, sample) results.append(row) print(json.dumps({'database': self.path.name, 'object': name, 'btree_GiB': round(row['btree_bytes'] / 2**30, 4), 'sample_rows': row.get('column_sample', {}).get('sample_rows')}), flush=True) lock_pages = int(self.path.stat().st_size > 1073741824) accounted = sum(item['btree_pages'] for item in results) + self.free_pages + lock_pages result = {'database': self.path.name, 'file_bytes': self.path.stat().st_size, 'page_size': self.pagesize, 'page_count': self.page_count, 'free_pages': self.free_pages, 'read_pages': self.read_pages, 'unassigned_pages_likely_overflow': self.page_count - accounted, 'objects': results} assert result['unassigned_pages_likely_overflow'] >= 0 self.conn.close() self.file.close() return result if __name__ == '__main__': import argparse parser = argparse.ArgumentParser(description=__doc__) parser.add_argument('--database', type=Path, required=True) parser.add_argument('--output', type=Path, required=True) args = parser.parse_args() start = time.monotonic() result = Audit(args.database.resolve(strict=True)).run() args.output.parent.mkdir(parents=True, exist_ok=True) args.output.write_text(json.dumps(result, indent=2), encoding='utf-8') print('COMPLETE', json.dumps({key: value for key, value in result.items() if key != 'objects'}), 'seconds', round(time.monotonic() - start, 2), flush=True)