| """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) | |