File size: 5,601 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 | """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):
# Check binary float values as well as NULL positions.
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()
|