rubydb 0.1.5 → 0.1.6

data/accelerator/internal/wal/record_encoder.go

@@ -0,0 +1,40 @@
+package wal
+
+import (
+	"encoding/binary"
+	"hash/crc32"
+)
+
+// EncodeRecord provides a versioned physical record format for future WAL
+// batching. Ruby remains responsible for LSN allocation and commit ordering.
+// Layout: magic(4), version(1), kind(1), LSN(8), transaction(8), length(4),
+// payload, CRC32(4).
+var recordMagic = [4]byte{'R', 'D', 'W', 'L'}
+
+func EncodeRecord(kind byte, lsn, transaction uint64, payload []byte) []byte {
+	const headerSize = 26
+	output := make([]byte, headerSize+len(payload)+4)
+	copy(output[:4], recordMagic[:])
+	output[4] = 1
+	output[5] = kind
+	binary.LittleEndian.PutUint64(output[6:14], lsn)
+	binary.LittleEndian.PutUint64(output[14:22], transaction)
+	binary.LittleEndian.PutUint32(output[22:26], uint32(len(payload)))
+	copy(output[26:], payload)
+	checksum := crc32.ChecksumIEEE(output[:26+len(payload)])
+	binary.LittleEndian.PutUint32(output[26+len(payload):], checksum)
+	return output
+}
+
+func VerifyRecord(record []byte) bool {
+	if len(record) < 30 || string(record[:4]) != string(recordMagic[:]) || record[4] != 1 {
+		return false
+	}
+	length := int(binary.LittleEndian.Uint32(record[22:26]))
+	if length < 0 || len(record) != 30+length {
+		return false
+	}
+	want := binary.LittleEndian.Uint32(record[len(record)-4:])
+	got := crc32.ChecksumIEEE(record[:len(record)-4])
+	return got == want
+}

data/adapters/activerecord/README.md

@@ -7,7 +7,7 @@ This gem is an adapter to RubyDB's SQL engine. It is not a PostgreSQL, MySQL, or
 ## Requirements
 
 - Ruby 3.3 or newer
-- RubyDB 0.1.x
+- RubyDB 0.1.6 or another compatible `0.1.x` release
 - ActiveRecord 7.1, 7.2, or 8.0 (the dependency range is `>= 7.1`, `< 8.1`)
 
 ## Install
@@ -15,8 +15,8 @@ This gem is an adapter to RubyDB's SQL engine. It is not a PostgreSQL, MySQL, or
 Add both gems to the Rails application's `Gemfile`:
 
 ```ruby
-gem "rubydb"
-gem "rubydb-activerecord"
+gem "rubydb", "~> 0.1.6"
+gem "rubydb-activerecord", "~> 0.1.3"
 ```
 
 Then run:
@@ -25,6 +25,11 @@ Then run:
 bundle install
 ```
 
+The core gem contains the optional Go accelerator and its platform binaries;
+the adapter does not require Go to be installed. RubyDB remains the SQL,
+transaction, WAL, and durability authority while the adapter exposes the
+Rails connection, query, migration, schema, and pool APIs.
+
 The adapter registers itself under the `rubydb` adapter name when it is
 required by Bundler. For a manually loaded application, require it explicitly:
 

data/adapters/activerecord/lib/active_record/connection_adapters/rubydb_adapter.rb

@@ -128,16 +128,15 @@ module ActiveRecord
       def primary_key(table_name)
         return @connection.engine.table_columns(table_name).find(&:primary_key?)&.name&.to_s || "id" if embedded?
 
-        result = execute("PRAGMA table_info(#{quote_table_name(table_name)})")
-        row = result.find { |r| r["pk"] == 1 }
-        row ? row["name"] : "id"
+        remote_metadata(table_name)[:columns].find do |column|
+          column[:primary_key] || column["primary_key"]
+        end&.then { |column| (column[:name] || column["name"]).to_s } || "id"
       end
 
       def tables
         return @connection.engine.list_tables.map(&:to_s) if embedded?
 
-        result = execute("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'")
-        result.map { |row| row["name"] }
+        Array(remote_metadata[:tables]).map(&:to_s)
       end
 
       def table_exists?(table_name)
@@ -148,21 +147,15 @@ module ActiveRecord
       # instantiated. The embedded engine has catalog metadata already, so
       # avoid generating unsupported SQLite catalog queries.
       def data_sources
-        return tables if embedded?
-
-        super
+        tables
       end
 
       def data_source_exists?(name)
-        return table_exists?(name) if embedded?
-
-        super
+        table_exists?(name)
       end
 
       def views
-        return [] if embedded?
-
-        super
+        []
       end
 
       def indexes(table_name)
@@ -177,30 +170,35 @@ module ActiveRecord
           end
         end
 
-        result = execute("SELECT name, sql FROM sqlite_master WHERE type='index' AND tbl_name=?", [table_name])
-        result.map do |row|
-          {
-            name: row["name"],
-            columns: parse_index_columns(row["sql"]),
-            unique: row["sql"].include?("UNIQUE")
-          }
+        Array(remote_metadata(table_name)[:indexes]).map do |index|
+          ActiveRecord::ConnectionAdapters::IndexDefinition.new(
+            table_name.to_s,
+            index[:name] || index["name"],
+            index[:unique] || index["unique"],
+            index[:columns] || index["columns"] || []
+          )
         end
       end
 
       def columns(table_name)
         return embedded_columns(table_name) if embedded?
 
-        result = execute("PRAGMA table_info(#{quote_table_name(table_name)})")
-        result.map do |row|
+        remote_columns(table_name)
+      end
+
+      def remote_columns(table_name)
+        Array(remote_metadata(table_name)[:columns]).map do |row|
+          type = row[:type] || row["type"]
+          nullable = row.key?(:nullable) ? row[:nullable] : row["nullable"]
           ActiveRecord::ConnectionAdapters::Column.new(
-            row["name"],
-            row["default"],
-            RubyDB::Rails::Type.to_rails(row["type"]),
-            {
-              null: row["notnull"] == 0,
-              primary_key: row["pk"] == 1,
-              limit: extract_limit(row["type"])
-            }
+            row[:name] || row["name"],
+            rails_default_value(row.key?(:default) ? row[:default] : row["default"]),
+            ActiveRecord::ConnectionAdapters::SqlTypeMetadata.new(
+              sql_type: type.to_s.upcase,
+              type: rails_type_for(type),
+              limit: extract_limit(type.to_s)
+            ),
+            nullable
           )
         end
       end
@@ -466,23 +464,25 @@ module ActiveRecord
       end
 
       def foreign_keys(table_name)
-        return super unless embedded?
-
-        constraints = @connection.engine.table_metadata[table_name.to_s]&.fetch(:constraints, []) || []
+        constraints = if embedded?
+          @connection.engine.table_metadata[table_name.to_s]&.fetch(:constraints, []) || []
+        else
+          Array(remote_metadata(table_name)[:constraints])
+        end
         constraints.filter_map do |constraint|
-          type = constraint[:type] || constraint["type"]
-          next unless type.to_s.upcase == "FOREIGN_KEY"
+          definition = constraint.transform_keys(&:to_sym)
+          next unless definition[:type].to_s.downcase.include?("foreign")
 
-          columns = constraint[:columns] || constraint["columns"] || []
-          reference_table = constraint[:reference_table] || constraint["reference_table"]
-          reference_columns = constraint[:reference_columns] || constraint["reference_columns"] || ["id"]
+          columns = definition[:columns] || []
+          reference_table = definition[:reference_table]
+          reference_columns = definition[:reference_columns] || ["id"]
           options = {
             column: Array(columns).first.to_s,
             primary_key: Array(reference_columns).first.to_s,
-            name: constraint[:name] || constraint["name"]
+            name: definition[:name]
           }
-          options[:on_delete] = (constraint[:on_delete] || constraint["on_delete"]).to_s if constraint[:on_delete] || constraint["on_delete"]
-          options[:on_update] = (constraint[:on_update] || constraint["on_update"]).to_s if constraint[:on_update] || constraint["on_update"]
+          options[:on_delete] = definition[:on_delete].to_s if definition[:on_delete]
+          options[:on_update] = definition[:on_update].to_s if definition[:on_update]
           ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(table_name.to_s, reference_table.to_s, options)
         end
       end
@@ -725,6 +725,12 @@ module ActiveRecord
         !@connection.engine.nil?
       end
 
+      def remote_metadata(table_name = nil)
+        raw = @connection.client.metadata(table_name)
+        metadata = raw[:metadata] || raw["metadata"] || raw
+        metadata.transform_keys(&:to_sym)
+      end
+
       def embedded_columns(table_name)
         @connection.engine.table_columns(table_name).map do |column|
           ActiveRecord::ConnectionAdapters::Column.new(
@@ -759,6 +765,8 @@ module ActiveRecord
       # persists typed defaults, so serialize scalar defaults at this boundary
       # and let ActiveRecord cast them through the column type map.
       def rails_default_value(value)
+        return nil if value.nil?
+
         # RubyDB exposes SQL defaults as AST literals. ActiveRecord expects
         # the scalar payload when it builds its Column metadata; calling
         # `to_s` on the wrapper would leak the Ruby object inspection into

data/adapters/activerecord/rubydb-activerecord.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name = "rubydb-activerecord"
-  spec.version = "0.1.2"
+  spec.version = "0.1.3"
   spec.authors = ["Aldane Hutchinson"]
   spec.email = ["aldanehutchinson5@gmail.com"]
 

data/docs/README.md

@@ -27,13 +27,15 @@ Start here:
 - [Workload testing](operations/workload-testing.md)
 - [Release checklist](release.md)
 - [Lessons learned](lessons-learned.md)
-- [Ten-lesson production journey](../lessons/01-foundations.md)
+- [Production journey](../lessons/01-foundations.md)
+- [Build a community adapter](../lessons/11-community-adapter.md)
 
 Architecture and development:
 
 - [Current-state audit](architecture/current-state.md)
 - [Production roadmap](architecture/production-roadmap.md)
 - [Architecture overview](architecture/overview.md)
+- [Ruby + Go accelerator](architecture/go-accelerator.md)
 - [Storage engine](architecture/storage-engine.md)
 - [Transactions](architecture/transactions.md)
 - [MVCC](architecture/mvcc.md)

data/docs/architecture/go-accelerator.md

@@ -0,0 +1,179 @@
+# Ruby + Go accelerator
+
+RubyDB installs as one Ruby package. Release gems include CGO-free Go
+executables for Windows amd64/arm64, Linux amd64/arm64, and macOS amd64/arm64. A
+developer needs Go only when building RubyDB itself or publishing a release;
+an application developer or production operator does not need Go installed.
+
+Ruby remains the database authority. It owns SQL meaning, physical-plan
+selection, transactions, MVCC visibility, locks, schema and constraints,
+permissions, WAL, recovery, and every commit decision. Go receives immutable
+read batches and returns data; it never writes database pages or decides what
+is committed.
+
+## Runtime boundary
+
+The Ruby process starts one long-lived private worker over stdin/stdout. The
+worker does not listen on a TCP port and is not reachable by application
+clients.
+
+```text
+application -> RubyDB parser/planner -> Ruby transaction and visibility checks
+                                      \-> Go binary read worker
+Ruby storage/WAL/MVCC/commit <--------- Ruby remains authoritative
+```
+
+The Go source is deliberately split by responsibility:
+
+```text
+accelerator/cmd/rubydb-accelerator/main.go   process entrypoint only
+accelerator/internal/runtime/                 request loop and dispatch
+accelerator/internal/protocol/                bounded frames and columnar batches
+accelerator/internal/execution/               filters, sorting, aggregates, joins
+accelerator/internal/storage/                 immutable snapshot page reads
+accelerator/internal/wal/                     checksums, compression, record batches
+accelerator/internal/parallel/                 bounded queues and worker scheduling
+accelerator/internal/memory/                  reusable arena and byte buffers
+accelerator/internal/metrics/                 operation counts and p95 timings
+```
+
+Each package has focused tests. The storage reader accepts only a page size,
+page list, and an immutable snapshot contract supplied by RubyDB; it does not
+open the catalog, WAL, or mutable page state by itself. This boundary is
+intentional: adding more Go code must not silently create a second transaction
+or recovery authority.
+
+Control messages use bounded JSON-lines. Large row operations use a versioned
+`RDBB` binary frame with a columnar batch: column names are sent once and
+values use typed, length-prefixed fields for NULL, booleans, integers, floats,
+strings, bytes, and JSON fallback values. Responses contain bounded metadata
+and one or more columnar result batches. This removes the old JSON/base64 row
+copy from the hot path while retaining a simple control protocol.
+
+Every frame has a request ID, protocol/version fields, a maximum size, and a
+structured error status. Startup verifies the binary against `SHA256SUMS`.
+Timeout, EOF, protocol mismatch, checksum failure, malformed data, or worker
+exit stops that worker. In `auto`, Ruby retries the operation on the Ruby
+executor; in `required`, the error is surfaced to the caller.
+
+## Accelerated work
+
+The current safe physical operators are:
+
+- immutable snapshot page and record decoding for eligible read-only scans;
+- immutable B-tree entry filtering for eligible indexed scans;
+- columnar serialization and deserialization;
+- deterministic parallel filtering for large batches;
+- filtering, projection, ordering, DISTINCT, and NULL-aware comparisons;
+- grouped `COUNT`, `SUM`, `AVG`, `MIN`, and `MAX`;
+- validated inner hash and merge joins;
+- portable `ROW_NUMBER`, `RANK`, `DENSE_RANK`, `LAG`, `LEAD`, and aggregate window operations;
+- SHA-256 checksums; and
+- gzip archive compression/decompression;
+- versioned WAL batch encoding, checksums, and optional compression; and
+- request-scoped cancellation, multiplexed requests, and bounded JSON result batches.
+
+WAL acceleration is deliberately a preparation boundary: Ruby assigns the
+transaction ID, LSN, commit order, and commit decision. Go returns an encoded
+and checksummed batch; Ruby is still responsible for writing the approved
+bytes, calling `fsync`, and publishing the durable acknowledgement. A failed
+or uncertain acknowledgement must remain a Ruby recovery error.
+
+The SQL executor delegates only plans it can describe with simple identifiers,
+literal predicates, and an eligible immutable read snapshot. Outer joins,
+complex expressions, writes, active transactions, and visibility-sensitive
+work stay in Ruby. The general row pipeline can also receive explicit
+projection, DISTINCT, HAVING, window, and merge-join specifications when the
+Ruby planner has already validated their semantics. Ruby applies every stage
+that was not delegated and remains the result authority through differential
+validation.
+
+### Immutable snapshot contract
+
+Before a snapshot scan Ruby flushes dirty pages, visibility metadata, and the
+table catalog while holding the engine lock. The default direct path records
+the page size/count, table page lists, schema, B-tree entries, and visibility
+exclusions in a manifest, then lets Go read the already-flushed database file
+while that lock remains held. This avoids copying and hashing the complete
+database for every read. `RUBYDB_ACCELERATOR_DIRECT_SNAPSHOT=off` (or
+`accelerator.direct_snapshot: false`) selects the detached fallback: Ruby
+copies the database to a short-lived private snapshot, records a SHA-256
+digest, and removes the copy after the request. Go verifies the file size,
+optional digest, page headers, record bounds, record flags, column count, and
+type lengths before returning rows.
+
+This path is intentionally conservative. Ruby declines it while the current
+thread has a transaction or any transaction is active. Go does not read WAL,
+catalog files, live indexes, or MVCC state and cannot publish writes. If a
+manifest, page, index entry, type, or result is invalid, `auto` falls back to
+the Ruby executor and `required` reports the error. The B-tree data is a
+consistent in-memory index snapshot because RubyDB rebuilds its indexes from
+metadata on open; it is not a new persisted index format.
+
+## Automatic selection
+
+The default is:
+
+```yaml
+accelerator:
+  mode: auto
+  read_pipeline: on
+  direct_snapshot: true
+  min_rows: 256
+```
+
+For each eligible snapshot scan, the first automatic operation is differentially
+checked against the Ruby implementation and timed. The result is recorded for
+both the physical snapshot scan and the row-batch scan family. Aggregate and
+join operations retain their own differential checks and timing. Utility
+operations record checksum, compression, and WAL-batch samples as well.
+`auto` keeps the Go operator only when it is faster and equivalent; otherwise
+that family falls back to Ruby for the lifetime of the worker. This avoids
+turning IPC overhead into a regression for small or already-optimized queries.
+The decision is process-local and is reset on restart, so it must be validated
+again after a deployment change.
+
+`mode: required` bypasses the speed decision and is intended for accelerator
+CI, release smoke tests, and deployments whose workload benchmark has already
+established a win. `mode: off` disables the worker entirely.
+
+```sh
+RUBYDB_ACCELERATOR=off rubydb doctor
+RUBYDB_ACCELERATOR=required rubydb accelerator --ping --json
+```
+
+The runtime reports capabilities, selected mode, checksum-verified binary,
+calibration decisions, and the last worker error in `rubydb accelerator
+--ping --json` and database statistics.
+
+## Building and packaging
+
+Release builds are cross-compiled with CGO disabled:
+
+```sh
+ruby scripts/build_accelerator
+RUBYDB_ACCELERATOR_TARGETS=current ruby scripts/build_accelerator
+bundle exec rake build:checksum
+```
+
+The gemspec packages the Ruby bridge, source module, six supported binaries,
+and the checksum manifest. A release preflight must run Go tests, Ruby
+accelerator tests, checksum verification, the extracted-gem handshake, and a
+representative workload benchmark before publishing.
+
+## Performance policy
+
+Go is intended to improve workloads dominated by scans, joins, aggregation,
+serialization, compression, or checksum work. It cannot promise that every
+query becomes seconds instead of minutes: indexes, disk latency, query shape,
+lock contention, and result size may dominate. The benchmark harness should
+report p50/p95/p99 latency, throughput, rows/sec, an RSS snapshot where the
+platform exposes it, worker/fallback metrics, and WAL-batch timing. CPU,
+process restarts, and host-level memory should be collected by the deployment
+monitor because those metrics are platform-specific. A speed claim is valid
+only for the measured workload and platform.
+
+Future shared immutable page snapshots and broader index/parallel operators
+must preserve the same contract: Go may read a versioned snapshot, but it may
+never mutate pages, indexes, catalog files, WAL, transaction state, or
+visibility state.

data/docs/cli.md

@@ -108,6 +108,30 @@ Use `inspect --wal` to correlate WAL growth with checkpoint/backup incidents.
 Do not edit files based on an inspection result; use the documented recovery
 procedure.
 
+## Go accelerator
+
+The accelerator is a private companion process, not a second server. Inspect
+the selected platform binary and perform a protocol handshake with:
+
+```sh
+rubydb accelerator --ping --json
+```
+
+Build it from a source checkout after installing Go:
+
+```sh
+ruby scripts/build_accelerator
+RUBYDB_ACCELERATOR_TARGETS=current ruby scripts/build_accelerator
+```
+
+Use `RUBYDB_ACCELERATOR=off` to reproduce a query on Ruby only. The default
+`mode: auto` uses the binary columnar protocol and calibrates each supported
+workload family against Ruby, falling back automatically when Go is slower or
+returns a mismatched result. `mode: required` is useful for CI differential
+tests and readiness validation. See the [Go accelerator
+architecture](architecture/go-accelerator.md) for modes, checksums, fallback,
+and package behavior.
+
 ## SQL shell
 
 Open the configured local database shell:

data/docs/contributing/benchmarking.md

@@ -6,9 +6,25 @@ Run deterministic and concurrent workloads from the repository root:
 RUBYDB_BENCHMARK_ITERATIONS=100 ruby -Ilib benchmarks/basic_workload.rb
 RUBYDB_SOAK_THREADS=16 RUBYDB_SOAK_OPERATIONS=2000 ruby benchmarks/concurrent_soak.rb
 RUBYDB_PRODUCTION_SOAK_CLIENTS=16 RUBYDB_PRODUCTION_SOAK_OPERATIONS=2000 ruby benchmarks/production_soak.rb
+# Ruby-vs-Go read pipeline benchmark (10,000 rows minimum)
+RUBYDB_ACCELERATOR_ROWS=10000 RUBYDB_ACCELERATOR_ITERATIONS=5 \
+RUBYDB_ACCELERATOR_THREADS=4 RUBYDB_ACCELERATOR_REQUESTS=5 \
+bundle exec ruby benchmarks/go_accelerator.rb
 ```
 
 Record commit, Ruby version, OS, CPU/memory/storage, dataset size, seed,
 throughput, p50/p95/p99 latency, WAL growth, and recovery time. Benchmarks are
 not universal capacity certification; compare against application-specific
 limits and repeat after schema or runtime changes.
+
+The accelerator benchmark reports separate Ruby and Go timings, correctness,
+CPU/RSS snapshots, concurrency errors, and worker lifecycle counters. It
+restarts the worker and verifies that concurrent requests return the same rows.
+A Go result is only useful if it is compared with the same rows, predicates,
+ordering, and result count. The Go leg uses `mode: required`; the Ruby leg is
+deliberately labeled `off` and does not invoke the worker. Set
+`RUBYDB_ACCELERATOR_REQUIRE_SPEED=1` in CI only when the representative
+workload has a known speed win. The runtime's `auto` policy performs an
+equivalent comparison per workload family before keeping an operator enabled.
+Keep the JSON output with the commit and hardware record; never use a single
+laptop run as a production capacity guarantee.

data/docs/developer/local-development.md

@@ -11,6 +11,38 @@ appropriate when testing process boundaries. Do not open one embedded path from
 multiple processes. Use the reported fuzz seed and commit when reproducing a
 failure.
 
+## Bundled Go accelerator
+
+The checkout includes the Go accelerator source under `accelerator/`. Go is
+needed to build RubyDB, not to run an installed gem. The release gem contains
+the platform binary and falls back to Ruby if a platform is not packaged. To
+build the binaries from a checkout:
+
+```sh
+ruby scripts/build_accelerator
+ruby -Ilib exe/rubydb accelerator --ping --json
+```
+
+Use Ruby-only mode while diagnosing a query difference:
+
+```sh
+RUBYDB_ACCELERATOR=off bundle exec rspec spec/sql_compatibility_spec.rb
+```
+
+The default `auto` mode uses the binary columnar protocol, checks result
+equivalence against Ruby on the first eligible scan/aggregate/join, and keeps
+Go only when it is faster. Use required mode in a controlled integration test
+to ensure a deployment has the expected binary:
+
+```yaml
+accelerator:
+  mode: required
+  min_rows: 0
+```
+
+The Go worker is private to its Ruby parent. It is not a database server and
+does not make an embedded file safe to open from multiple processes.
+
 Start with the [developer guide](../developer-guide.md). For failures, use a
 fresh copy, preserve WAL and metadata, run the narrowest spec first, then the
 full suite. The [debugging playbook](../debugging.md) describes safe logging,

data/docs/release.md

@@ -28,7 +28,7 @@ version to be supplied when you are not running from a matching Git tag.
 On Windows PowerShell, run this from the repository root:
 
 ```powershell
-$env:RUBYDB_RELEASE_VERSION = "0.1.5"
+$env:RUBYDB_RELEASE_VERSION = "0.1.6"
 $env:RUBYDB_PUBLISH = "1"
 $env:GEM_HOST_API_KEY = "YOUR_RUBYGEMS_API_KEY"
 ruby scripts/release
@@ -49,7 +49,7 @@ file automatically. Keep the file private and never commit it.
 On macOS/Linux, use:
 
 ```sh
-RUBYDB_RELEASE_VERSION=0.1.5 \
+RUBYDB_RELEASE_VERSION=0.1.6 \
 RUBYDB_PUBLISH=1 \
 GEM_HOST_API_KEY="YOUR_RUBYGEMS_API_KEY" \
 ruby scripts/release

data/lessons/02-local-development.md

@@ -12,8 +12,8 @@ RubyDB project at the time this lesson was written.
 
 ```ruby
 # Gemfile
-gem "rubydb", "0.1.5"
-gem "rubydb-activerecord", "0.1.2"
+gem "rubydb", "0.1.6"
+gem "rubydb-activerecord", "0.1.3"
 gem "pg" # Keep this when production may use PostgreSQL.
 ```
 

data/lessons/04-rails-complex-apps.md

@@ -9,8 +9,8 @@ topology you will deploy.
 
 ```ruby
 # Gemfile
-gem "rubydb", "0.1.5"
-gem "rubydb-activerecord", "0.1.2"
+gem "rubydb", "0.1.6"
+gem "rubydb-activerecord", "0.1.3"
 ```
 
 Embedded development configuration:

data/lessons/05-rubydb-production-server.md

@@ -11,7 +11,7 @@ Use a dedicated service account and persistent storage. The commands below
 assume a Unix-like host; adapt ownership commands to your platform:
 
 ```sh
-gem install rubydb -v 0.1.5
+gem install rubydb -v 0.1.6
 install -d -o rubydb -g rubydb -m 0700 /var/lib/rubydb/data
 install -d -o rubydb -g rubydb -m 0750 /var/log/rubydb
 install -d -o rubydb -g rubydb -m 0700 /etc/rubydb
@@ -62,7 +62,7 @@ and a private network route from the application. Run these commands as an
 administrator and replace paths only after verifying the target host:
 
 ```sh
-gem install rubydb -v 0.1.5
+gem install rubydb -v 0.1.6
 useradd --system --home-dir /var/lib/rubydb --shell /usr/sbin/nologin rubydb
 install -d -o rubydb -g rubydb -m 0700 /var/lib/rubydb/data
 install -d -o rubydb -g rubydb -m 0750 /var/log/rubydb