herringbone 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1148482072b7346372f0ce7d404c237359dbda86443c0b12dd8200937f6336cc
+  data.tar.gz: 9c1abff1ff39a715b0cb32f9bb9385d3642cdf6a0f2f5f6c45e741f25832ca21
+SHA512:
+  metadata.gz: 84e2d8192f4a0e9e15430cf8df20d1dd070028dc3561973d639ca887ff82c8673e7864063419a63b05649526ccf6dd0f2a6eb9d291067fd5c674a2ba76ec9771
+  data.tar.gz: 532f1deff266b6f4867f47c6e80b200cfa9bcdb1a5d45442ef8e40b5f25247087fa2a85975822c3f572c6a64575ae6b4f87bbd72a13df1143db2a0c82fde856b

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Julik Tarkhanov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,209 @@
+# Herringbone
+
+A pure-Ruby reader and writer for [Apache Parquet](https://parquet.apache.org/) files.
+
+- No native extensions, no Thrift gem: the Thrift compact protocol, all encodings and the
+  Snappy and LZ4 codecs are implemented in Ruby
+- Full nesting support (structs, lists, maps, any depth) via Dremel record shredding/assembly
+- Reads files from parquet-mr, Arrow, Spark, Impala, DuckDB, Rust writers etc.
+- Ruby 3.0+
+
+## Installation
+
+```ruby
+gem "herringbone"
+```
+
+Snappy and LZ4 are implemented in Ruby, GZIP uses `zlib`, and ZSTD and Brotli come from the
+`zstd-ruby` and `brotli` gems (runtime dependencies, along with `bigdecimal`).
+
+## Reading
+
+```ruby
+require "herringbone"
+
+Herringbone::Reader.open("data.parquet") do |reader|
+  reader.schema             # => #<Herringbone::Schema ...>
+  reader.num_rows
+
+  reader.each_row do |row|  # Hash with String keys, nested values as Hash/Array
+    p row
+  end
+
+  reader.each_row(columns: ["id", "name"]) { |row| ... } # projection
+  reader.column("name")     # => all values of one top-level field
+  reader.read_row_group(0)  # => { "id" => [...], "name" => [...] }
+end
+
+Herringbone.read("data.parquet") # => Array of row Hashes
+```
+
+## Writing
+
+```ruby
+schema = Herringbone::Schema.define do
+  int64 :id, null: false
+  string :name
+  enum :status, values: %w[pending paid shipped]
+  list :tags, :string
+  map :scores, :string, :double
+  struct :address do
+    string :city
+    string :zip
+  end
+  decimal :price, precision: 12, scale: 2
+  json :payload
+  timestamp :created_at
+end
+
+Herringbone::Writer.open("out.parquet", schema) do |w|
+  w << { "id" => 1, "name" => "Anna", "status" => "paid", "tags" => ["a", "b"],
+         "scores" => { "x" => 1.5 }, "address" => { "city" => "Amsterdam" },
+         "price" => BigDecimal("9.99"), "payload" => { "any" => ["json"] }, "created_at" => Time.now }
+  w << { id: 2, status: :pending }  # Symbol keys and values work; missing keys are nulls
+  w << [3, "Bo", nil, nil, nil, nil, nil, nil, nil, nil] # Arrays in schema order
+  w << order                         # anything with #attributes (ActiveRecord) or #to_h (Struct, Data)
+end
+
+# Or with an inferred schema, optionally overriding some columns
+Herringbone.write("out.parquet", rows, schema: Herringbone::Schema.infer(rows, types: { payload: :json }))
+```
+
+Schemas can also be given as a Hash, anywhere a schema is accepted:
+
+```ruby
+Herringbone::Schema.define(
+  id: { type: :int64, null: false },
+  name: :string,
+  tags: [:string],                                   # list of strings
+  address: { city: :string, zip: :string },          # struct
+  price: { type: :decimal, precision: 12, scale: 2 },
+  scores: { type: :map, key: :string, value: :double }
+)
+Herringbone::Writer.open("out.parquet", { id: :int64, name: :string }) { |w| w << [1, "x"] }
+```
+
+Column types in the DSL: `boolean int8 int16 int32 int64 uint8 uint16 uint32 uint64 float double
+float16 string binary json bson enum uuid date int96 time timestamp decimal fixed`, plus
+`struct`, `list` and `map`. Fields are nullable unless `null: false` is given.
+List elements are nullable unless `element_null: false`; map values unless `value_null: false`.
+Nested lists: `list :matrix do list :element, :double end`.
+
+`enum` is a string column. `values:` restricts what may be written, and also takes a Rails-style
+Hash (`values: Order.statuses`), in which case both labels and stored integers are accepted and
+the label is written. `parquet_enum: true` adds the Parquet ENUM annotation (pyarrow and pandas
+read such columns as binary, which is why it is off by default).
+
+Columns accept the values Ruby and Rails code usually has at hand:
+
+| column | accepts |
+|---|---|
+| `date` | `Date`, `Time`/`DateTime` (their date), `"2024-05-01"` |
+| `timestamp` | `Time`, `DateTime`, `ActiveSupport::TimeWithZone`, `Date` (midnight UTC), ISO-8601 strings, Integers in the column's unit |
+| `time` | `Time` (its time of day, as Rails returns for `time` columns), `"13:45:30.25"`, Integers |
+| `json` | Strings as-is, anything else through `JSON.generate` |
+| `string`, `enum` | Strings, Symbols, anything with `to_s` |
+| `boolean` | `true`/`false`, `1`/`0`, `"t"`/`"f"`, `"true"`/`"false"`, `"yes"`/`"no"` |
+| integers | Integers, whole-number Floats/BigDecimals/Rationals, numeric Strings; out-of-range values raise |
+| `decimal` | `BigDecimal`, Integer, Rational, Float, numeric Strings |
+| `uuid` | Strings with or without dashes, or 16 raw bytes |
+
+Values that don't fit raise `Herringbone::EncodeError` naming the row number and column path; the
+failed row is discarded and the writer can carry on.
+
+When given a path, the writer writes to a temporary file next to it and renames it into place on
+close. If the block raises (or `#abort` is called), the temporary file is removed and any
+existing file at the path is left untouched. An IO (`File`, `StringIO`, a socket...) can be
+given instead of a path.
+
+Writer options:
+
+| option | default | |
+|---|---|---|
+| `compression` | `:zstd` | `:none`, `:snappy`, `:gzip`, `:lz4` (LZ4_RAW), `:lz4_hadoop`, `:zstd`, `:brotli` |
+| `row_group_bytes` | 16MB | flush a row group once the buffered values take about this much memory; bounds memory use. Low-cardinality string columns are dictionary-encoded as rows arrive and other strings are packed into byte buffers, so a 15-column table exported in 16MB groups peaks around 290 MB RSS (420 MB with 64MB groups) |
+| `row_group_size` | none | also flush after this many rows |
+| `page_size` | 1MB | approximate data page size |
+| `data_page_version` | `1` | `1` or `2` |
+| `dictionary` | `true` | `false`, or an Array of column paths to dictionary-encode |
+| `encodings` | `{}` | e.g. `{ "id" => :delta_binary_packed, "x" => :byte_stream_split }` |
+| `statistics` | `true` | write min/max/null_count |
+| `metadata` | `{}` | footer key/value metadata |
+
+## Exporting ActiveRecord models
+
+`Herringbone::Schema.from_active_record` builds a schema from a model's columns, so that
+`record.attributes` can be written as-is. Rails is not a dependency: it only calls
+`columns`, `primary_key` and `defined_enums` on the model.
+
+```ruby
+schema = Herringbone::Schema.from_active_record(Order)
+Herringbone::Writer.open("orders.parquet", schema) do |w|
+  Order.find_each { |order| w << order.attributes }
+end
+```
+
+Options: `only:` and `except:` take attribute names; `enums: :enum` writes enum attributes with
+the Parquet ENUM annotation instead of as plain strings (the default, `enums: :string`). Enum
+attributes are written as their labels, and the writer rejects values outside the enum.
+
+| Column | Parquet |
+|---|---|
+| `integer` | `int16`/`int32`/`int64` by SQL type (`smallint`, `integer`, `bigint`...) or limit; `uintN` for `unsigned`; primary keys are always `int64` |
+| `float` | `double` (`float` for Postgres `float4`) |
+| `decimal` | `decimal(precision, scale)`; `decimal(38, 9)` when the column has no precision |
+| `boolean`, `date`, `binary`, `uuid` | same |
+| `json`, `jsonb` | `json` |
+| `datetime`, `timestamp`, `timestamptz` | `timestamp` (microseconds, UTC) |
+| `time` | `time` (microseconds) |
+| `hstore` | `map` of `string` to `string` |
+| enum attributes | `string` (or `enum`) |
+| `string`, `text`, `citext`, anything else | `string` |
+| Postgres array columns | `list` of the element type |
+
+Columns declared `NOT NULL` (and primary keys) are required, all others nullable.
+Column order follows `Model.columns`.
+
+## Type mapping
+
+| Parquet | Ruby |
+|---|---|
+| BOOLEAN | `true`/`false` |
+| INT32/INT64 (incl. signed/unsigned INTEGER) | `Integer` |
+| FLOAT, DOUBLE, FLOAT16 | `Float` |
+| STRING, ENUM, JSON | `String` (UTF-8) |
+| BYTE_ARRAY, FIXED_LEN_BYTE_ARRAY, BSON | `String` (binary) |
+| DATE | `Date` (proleptic Gregorian) |
+| TIMESTAMP, INT96 | `Time` (UTC) |
+| TIME | `Integer` in the column's unit since midnight |
+| DECIMAL | `BigDecimal` |
+| UUID | `String` like `"0f1e2d3c-..."` |
+| struct / list / map | `Hash` / `Array` / `Hash` |
+
+## Supported format features
+
+- Encodings (read and write): PLAIN, PLAIN_DICTIONARY/RLE_DICTIONARY, RLE, DELTA_BINARY_PACKED,
+  DELTA_LENGTH_BYTE_ARRAY, DELTA_BYTE_ARRAY, BYTE_STREAM_SPLIT; legacy BIT_PACKED levels (read)
+- Data page v1 and v2, dictionary pages, page CRCs (written)
+- Legacy list and map layouts per the Parquet backward-compatibility rules
+- Not supported: encryption, column chunks in external files, bloom filters and page indexes
+  (ignored when reading, not written)
+
+## Command line
+
+```
+bin/herringbone schema FILE
+bin/herringbone meta FILE
+bin/herringbone cat FILE [N]
+```
+
+## Development
+
+```
+bundle install
+bundle exec rake test
+HERRINGBONE_PYTHON=/path/to/python-with-pyarrow bundle exec rake test   # also run pyarrow interop tests
+```
+
+`test/fixtures/parquet-testing` holds files from [apache/parquet-testing](https://github.com/apache/parquet-testing)
+(Apache-2.0); expectations for them were generated with pyarrow, see `test/fixtures/generate_expectations.py`.

data/bin/herringbone

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Usage:
+#   herringbone schema FILE        print the schema
+#   herringbone meta FILE          print row groups, codecs and encodings
+#   herringbone cat FILE [N]       print rows as JSON lines (optionally only the first N)
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "herringbone"
+require "json"
+
+def jsonable(v)
+  case v
+  when Hash then v.to_h { |k, x| [k.to_s, jsonable(x)] }
+  when Array then v.map { |x| jsonable(x) }
+  when String then v.encoding == Encoding::BINARY && !v.ascii_only? ? v.unpack1("H*") : v
+  when Float then v.finite? ? v : v.to_s
+  when Time then v.iso8601(9)
+  when Date then v.iso8601
+  when Integer, true, false, nil then v
+  else v.to_s
+  end
+end
+
+command, path, limit = ARGV
+unless %w[schema meta cat].include?(command) && path
+  warn "usage: herringbone (schema|meta|cat) FILE [N]"
+  exit 1
+end
+
+Herringbone::Reader.open(path) do |r|
+  case command
+  when "schema"
+    puts r.schema.inspect
+  when "meta"
+    puts "rows: #{r.num_rows}, row groups: #{r.num_row_groups}, created by: #{r.created_by}"
+    r.key_value_metadata.each { |k, v| puts "  #{k} = #{v.to_s[0, 80]}" }
+    r.row_groups.each_with_index do |rg, i|
+      puts "row group #{i}: #{rg.num_rows} rows"
+      rg.columns.each do |cc|
+        m = cc.meta_data
+        encodings = m.encodings.map { |e| Herringbone::Format::Encoding::NAMES[e] }.join(",")
+        puts "  #{m.path_in_schema.join(".")}: #{Herringbone::Format::Codec::NAMES[m.codec]} #{encodings} " \
+          "#{m.total_compressed_size}/#{m.total_uncompressed_size} bytes"
+      end
+    end
+  when "cat"
+    n = limit&.to_i
+    r.each_row.with_index do |row, i|
+      break if n && i >= n
+      puts JSON.generate(jsonable(row))
+    end
+  end
+end

data/lib/herringbone/active_record.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Herringbone
+  class Schema
+    # Builds a schema from an ActiveRecord model, so that the Hashes returned by
+    # +record.attributes+ can be written directly:
+    #
+    #   schema = Herringbone::Schema.from_active_record(Order)
+    #   Herringbone::Writer.open("orders.parquet", schema) do |w|
+    #     Order.find_each { |order| w << order.attributes }
+    #   end
+    #
+    # ActiveRecord is not required: this only uses what a model class exposes
+    # (+columns+, +primary_key+ and, when present, +defined_enums+).
+    #
+    # only:   attribute names to include (Strings or Symbols)
+    # except: attribute names to leave out
+    # enums:  :string (default) writes enum attributes as STRING columns, :enum uses the
+    #         Parquet ENUM annotation (which pyarrow/pandas read as binary). Either way the
+    #         enum labels are written, and the writer rejects values outside the enum mapping
+    #         (stored values such as 0/1 are accepted and written as their labels).
+    def self.from_active_record(model, only: nil, except: nil, enums: :string)
+      raise ArgumentError, "enums: must be :string or :enum" unless %i[string enum].include?(enums)
+      only = only && Array(only).map(&:to_s)
+      except = Array(except).map(&:to_s)
+      defined_enums = model.respond_to?(:defined_enums) ? model.defined_enums.to_h { |k, v| [k.to_s, v] } : {}
+      primary_keys = Array(model.respond_to?(:primary_key) ? model.primary_key : nil).map(&:to_s)
+
+      builder = Builder.new
+      model.columns.each do |column|
+        name = column.name.to_s
+        next if only && !only.include?(name)
+        next if except.include?(name)
+        primary = primary_keys.include?(name)
+        nullable = column.null != false && !primary
+        if (mapping = defined_enums[name])
+          builder.enum(name, values: mapping.to_h, parquet_enum: enums == :enum, null: nullable)
+        else
+          ActiveRecordMapping.add_column(builder, column, nullable, primary)
+        end
+      end
+      raise ArgumentError, "No columns selected from #{model}" if builder.nodes.empty?
+      new(Node.new(name: "schema", repetition: :required, children: builder.nodes))
+    end
+
+    # Maps ActiveRecord column metadata to schema DSL types.
+    #
+    #   integer   by sql_type (smallint -> int16, bigint -> int64, ...) or by limit
+    #             (1 -> int8, 2 -> int16, 8 -> int64, otherwise int32); "unsigned" -> uintN.
+    #             Integer primary keys are always int64.
+    #   float     double; float (32-bit) only for sql_type "float4"
+    #   decimal   decimal(precision, scale); decimal(38, 9) when the column has no precision
+    #   boolean, date, binary, uuid, json map to the same-named types (jsonb -> json)
+    #   datetime, timestamp, timestamptz -> timestamp(micros, UTC); time -> time(micros)
+    #   hstore    map<string, string>
+    #   anything else (string, text, citext, inet, cidr, macaddr, ...) -> string
+    #   Postgres arrays (column.array, or a sql_type ending in "[]") -> list of the element type
+    module ActiveRecordMapping
+      module_function
+
+      DEFAULT_DECIMAL_PRECISION = 38
+      DEFAULT_DECIMAL_SCALE = 9
+
+      INTEGER_SQL_TYPES = {
+        "tinyint" => 8, "int1" => 8,
+        "smallint" => 16, "int2" => 16, "smallserial" => 16, "serial2" => 16,
+        "mediumint" => 32, "int4" => 32, "serial" => 32, "serial4" => 32,
+        "bigint" => 64, "int8" => 64, "bigserial" => 64, "serial8" => 64
+      }.freeze
+
+      def add_column(builder, column, nullable, primary)
+        sql_type = column.respond_to?(:sql_type) ? column.sql_type.to_s.downcase : ""
+        array = (column.respond_to?(:array) && column.array) || sql_type.end_with?("[]")
+        sql_type = sql_type.sub(/(\[\d*\])+\z/, "")
+        type = column.type&.to_sym
+
+        if type == :hstore
+          return builder.map(column.name, :string, :string, null: nullable) unless array
+          return builder.list(column.name, null: nullable) { map :element, :string, :string }
+        end
+
+        dsl_type, opts = scalar_type(column, type, sql_type, primary)
+        if array
+          builder.list(column.name, dsl_type, null: nullable, **opts)
+        else
+          builder.column(column.name, dsl_type, null: nullable, **opts)
+        end
+      end
+
+      def scalar_type(column, type, sql_type, primary)
+        case type
+        when :integer, :bigint then [integer_type(column, sql_type, primary), {}]
+        when :float then [sql_type == "float4" ? :float : :double, {}]
+        when :decimal, :money
+          precision = column.respond_to?(:precision) ? column.precision : nil
+          scale = column.respond_to?(:scale) ? column.scale : nil
+          if precision.nil?
+            precision = DEFAULT_DECIMAL_PRECISION
+            scale ||= DEFAULT_DECIMAL_SCALE
+          end
+          [:decimal, { precision: precision, scale: scale || 0 }]
+        when :boolean then [:boolean, {}]
+        when :binary then [:binary, {}]
+        when :date then [:date, {}]
+        when :datetime, :timestamp, :timestamptz then [:timestamp, { unit: :micros, utc: true }]
+        when :time then [:time, { unit: :micros }]
+        when :json, :jsonb then [:json, {}]
+        when :uuid then [:uuid, {}]
+        else [:string, {}]
+        end
+      end
+
+      # Named SQL types (smallint, bigint, ...) decide the width; a generic "integer"/"int"
+      # uses the column limit in bytes, since e.g. SQLite reports `t.integer limit: 2` as "integer(2)".
+      def integer_type(column, sql_type, primary)
+        bits = INTEGER_SQL_TYPES[sql_type[/\A[a-z0-9]+/]]
+        bits ||= case (column.respond_to?(:limit) ? column.limit : nil)
+        when 1 then 8
+        when 2 then 16
+        when 5..8 then 64
+        else 32
+        end
+        # Row ids can exceed 32 bits even where the column is declared "integer" (SQLite rowids)
+        bits = 64 if primary
+        unsigned = sql_type.include?("unsigned")
+        return :"uint#{bits}" if unsigned
+        { 8 => :int8, 16 => :int16, 32 => :int32, 64 => :int64 }.fetch(bits)
+      end
+    end
+  end
+end

data/lib/herringbone/byte_values.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Herringbone
+  # Compact buffer for the values of a BYTE_ARRAY or FIXED_LEN_BYTE_ARRAY column while a row
+  # group is being collected. Instead of holding on to one Ruby String per value, it either
+  #
+  # * dictionary-encodes values as they arrive (keeping each distinct value once, plus an Integer
+  #   index per value), which suits low-cardinality columns such as enums and statuses, or
+  # * appends the raw bytes to one binary String (plus a length per value for BYTE_ARRAY).
+  #
+  # It starts out in dictionary mode (when allowed) and switches to raw bytes once the dictionary
+  # grows too large or too many values turn out to be distinct. Strings are only rebuilt when the
+  # row group is flushed, one column at a time.
+  class ByteValues
+    # Values in the dictionary may take this many bytes before switching to raw bytes
+    MAX_DICTIONARY_BYTES = 1024 * 1024
+    # After this many values, give up on the dictionary if more than half of them are distinct
+    CARDINALITY_CHECK_AT = 4096
+
+    APPEND_AS_BYTES = "".respond_to?(:append_as_bytes)
+
+    def initialize(width: nil, dictionary: true)
+      @width = width
+      @bytes = String.new(encoding: Encoding::BINARY)
+      @lengths = width ? nil : []
+      @count = 0
+      if dictionary
+        @dictionary = {}
+        @dictionary_bytes = 0
+        @indices = []
+      end
+    end
+
+    def size
+      @indices ? @indices.size : @count
+    end
+
+    def empty? = size.zero?
+
+    def dictionary? = !@indices.nil?
+
+    def <<(value)
+      if @indices
+        index = @dictionary[value]
+        if index.nil?
+          if @dictionary_bytes + value.bytesize > MAX_DICTIONARY_BYTES
+            switch_to_bytes
+            return append_bytes(value)
+          end
+          # Hash#[]= stores a frozen copy of unfrozen String keys
+          index = @dictionary.size
+          @dictionary[value] = index
+          @dictionary_bytes += value.bytesize + 4
+        end
+        @indices << index
+        switch_to_bytes if @indices.size == CARDINALITY_CHECK_AT && @dictionary.size > CARDINALITY_CHECK_AT / 2
+        self
+      else
+        append_bytes(value)
+      end
+    end
+
+    # Removes the last value
+    def pop
+      truncate(size - 1) unless size.zero?
+    end
+
+    # Supports the `slice!(n..)` form used to roll back a failed row
+    def slice!(range)
+      truncate(range.begin)
+    end
+
+    # Approximate memory held, used to size row groups
+    def memory_bytes
+      if @indices
+        # Each distinct value is a String object plus a Hash entry
+        @indices.size * 8 + @dictionary_bytes + @dictionary.size * 48
+      else
+        @bytes.bytesize + (@lengths ? @lengths.size * 8 : 0)
+      end
+    end
+
+    # Returns [:dictionary, values, indices] when the column is worth dictionary-encoding,
+    # otherwise [:plain, values]
+    def materialize
+      if @indices
+        keys = @dictionary.keys
+        return [:dictionary, keys, @indices] unless keys.size > @indices.size / 2 + 1 && @indices.size > 16
+        return [:plain, @indices.map { |i| keys[i] }]
+      end
+      [:plain, strings]
+    end
+
+    private
+
+    def append_bytes(value)
+      if value.encoding == Encoding::BINARY || value.ascii_only?
+        @bytes << value
+      elsif APPEND_AS_BYTES
+        @bytes.append_as_bytes(value)
+      else
+        @bytes << value.b
+      end
+      @lengths << value.bytesize if @lengths
+      @count += 1
+      self
+    end
+
+    def switch_to_bytes
+      keys = @dictionary.keys
+      indices = @indices
+      @indices = @dictionary = nil
+      indices.each { |i| append_bytes(keys[i]) }
+    end
+
+    def truncate(n)
+      if @indices
+        @indices.slice!(n..)
+      else
+        keep = if @lengths
+          @lengths.slice!(n..)
+          @lengths.sum
+        else
+          n * @width
+        end
+        @bytes.slice!(keep..)
+        @count = n
+      end
+    end
+
+    def strings
+      if @lengths
+        pos = 0
+        @lengths.map do |len|
+          s = @bytes.byteslice(pos, len)
+          pos += len
+          s
+        end
+      else
+        Array.new(@count) { |i| @bytes.byteslice(i * @width, @width) }
+      end
+    end
+  end
+end