File size: 8,462 Bytes
9a1f607 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 | """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)
|