| """Compare lossless storage on a distributed sample. Source is read-only."""
|
| from pathlib import Path
|
| import gc
|
| import json
|
| import sqlite3
|
| import struct
|
| import time
|
|
|
| import duckdb
|
| import pyarrow as pa
|
| import pyarrow.compute
|
| import pyarrow.parquet as pq
|
|
|
| ROOT = Path(__file__).parent
|
| SOURCE = None
|
| TOTAL_ROWS = 255594909
|
| FIELDS = [
|
| ('rowid', pa.int64()), ('track_id', pa.string()), ('fetched_at', pa.int64()),
|
| ('null_response', pa.int64()), ('duration_ms', pa.int64()), ('time_signature', pa.int64()),
|
| ('tempo', pa.float64()), ('key', pa.int64()), ('mode', pa.int64()),
|
| ('danceability', pa.float64()), ('energy', pa.float64()), ('loudness', pa.float64()),
|
| ('speechiness', pa.float64()), ('acousticness', pa.float64()),
|
| ('instrumentalness', pa.float64()), ('liveness', pa.float64()), ('valence', pa.float64()),
|
| ]
|
| SCHEMA = pa.schema(FIELDS)
|
|
|
|
|
| def exact_equal(left, right):
|
| assert left.column_names == right.column_names
|
| assert left.num_rows == right.num_rows
|
| for field in left.schema:
|
| a, b = left[field.name].combine_chunks(), right[field.name].combine_chunks()
|
| if pa.types.is_floating(field.type):
|
|
|
| assert a.is_null().equals(b.is_null()), field.name
|
| assert pa.compute.fill_null(a, 0).buffers()[1].to_pybytes() == pa.compute.fill_null(b, 0).buffers()[1].to_pybytes(), field.name
|
| else:
|
| assert a.equals(b), field.name
|
|
|
|
|
| def main():
|
| conn = sqlite3.connect(SOURCE.as_uri() + '?mode=ro&immutable=1', uri=True)
|
| conn.execute('PRAGMA cache_size=-8192')
|
| last = conn.execute('SELECT rowid FROM track_audio_features ORDER BY rowid DESC LIMIT 1').fetchone()[0]
|
| batches = []
|
| windows = 32
|
| window_rows = 8192
|
| names = ','.join('"' + name + '"' for name, _ in FIELDS)
|
| for i in range(windows):
|
| start = 1 + ((last - window_rows - 1) * i // (windows - 1))
|
| rows = conn.execute(f'SELECT {names} FROM track_audio_features WHERE rowid>=? ORDER BY rowid LIMIT ?', (start, window_rows)).fetchall()
|
| arrays = [pa.array([row[j] for row in rows], type=kind) for j, (_, kind) in enumerate(FIELDS)]
|
| batches.append(pa.RecordBatch.from_arrays(arrays, schema=SCHEMA))
|
| del rows, arrays
|
| conn.close()
|
| table = pa.Table.from_batches(batches)
|
| print('SAMPLE', table.num_rows, 'rows', 'Arrow_bytes', table.nbytes, 'max_rowid', last, flush=True)
|
| dictionaries = [name for name, _ in FIELDS if name != 'track_id']
|
| encodings = {name: ('BYTE_STREAM_SPLIT' if pa.types.is_floating(kind) else 'DELTA_LENGTH_BYTE_ARRAY' if pa.types.is_string(kind) else 'DELTA_BINARY_PACKED') for name, kind in FIELDS}
|
| configs = [
|
| ('snappy_dictionary', {'compression': 'snappy', 'use_dictionary': dictionaries}),
|
| ('zstd9_dictionary', {'compression': 'zstd', 'compression_level': 9, 'use_dictionary': dictionaries}),
|
| ('zstd19_dictionary', {'compression': 'zstd', 'compression_level': 19, 'use_dictionary': dictionaries}),
|
| ('zstd19_split_delta', {'compression': 'zstd', 'compression_level': 19, 'use_dictionary': False, 'column_encoding': encodings}),
|
| ]
|
| results = []
|
| for label, config in configs:
|
| target = ROOT / ('audio_sample_' + label + '.parquet')
|
| start = time.monotonic()
|
| pq.write_table(table, target, row_group_size=262144, write_statistics=True, **config)
|
| seconds = time.monotonic() - start
|
| exact_equal(table, pq.read_table(target))
|
| size = target.stat().st_size
|
| result = {'format': label, 'sample_rows': table.num_rows, 'sample_bytes': size, 'projected_full_GiB': size / table.num_rows * TOTAL_ROWS / 2**30, 'write_seconds': round(seconds, 3), 'all_values_exact': True}
|
| results.append(result)
|
| print(json.dumps(result), flush=True)
|
| target = ROOT / 'audio_sample.duckdb'
|
| assert not target.exists(), target
|
| db = duckdb.connect(str(target))
|
| db.execute("SET memory_limit='256MB'")
|
| db.register('audio_sample', table)
|
| start = time.monotonic()
|
| db.execute('CREATE TABLE track_audio_features AS SELECT * FROM audio_sample')
|
| db.execute('CHECKPOINT')
|
| seconds = time.monotonic() - start
|
| restored = db.execute('SELECT * FROM track_audio_features').fetch_arrow_table()
|
| exact_equal(table, restored)
|
| db.close()
|
| size = target.stat().st_size
|
| result = {'format': 'duckdb_native', 'sample_rows': table.num_rows, 'sample_bytes': size, 'projected_full_GiB': size / table.num_rows * TOTAL_ROWS / 2**30, 'write_seconds': round(seconds, 3), 'all_values_exact': True}
|
| results.append(result)
|
| print(json.dumps(result), flush=True)
|
| (ROOT / 'audio_compression_results.json').write_text(json.dumps({'source_bytes': SOURCE.stat().st_size, 'source_rows': TOTAL_ROWS, 'sample_windows': windows, 'results': results}, indent=2), encoding='utf-8')
|
|
|
|
|
| if __name__ == '__main__':
|
| import argparse
|
| parser = argparse.ArgumentParser(description=__doc__)
|
| parser.add_argument('--database', type=Path, required=True)
|
| parser.add_argument('--output-dir', type=Path, required=True)
|
| parser.add_argument('--total-rows', type=int, default=TOTAL_ROWS)
|
| args = parser.parse_args()
|
| SOURCE = args.database.resolve(strict=True)
|
| ROOT = args.output_dir.resolve()
|
| ROOT.mkdir(parents=True, exist_ok=True)
|
| if any(ROOT.iterdir()):
|
| parser.error('Choose an empty benchmark output directory')
|
| TOTAL_ROWS = args.total_rows
|
| main()
|
|
|
