extralite 2.6 → 2.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a18a0c22e187c1f3211611b67dcd5f60040ec794d63dfe3a125bdd0174b108a
-  data.tar.gz: 050e95afc37f01145b860e861c1ceba37da134c878e44f9c49bf9adec2894651
+  metadata.gz: 2cbb8c1507e23141a2b069306e31939b7cd5fea83e6941426972d7eeadc86ac0
+  data.tar.gz: e283cd0d2b18ed840020d73fb71d47696b64b8ff99c42a2a431928b6a25db189
 SHA512:
-  metadata.gz: 6e45c3ced0207aa163658bcf8317d10967572e533a83953b41039fde740aadda78e1fe01a55302a7c5925326f256b29ff18d1a6234c7625ffad8340624758219
-  data.tar.gz: f9401d194c8481fa4a057e4d37b673b06ea1a22beafbd5b3406de5aaceb553efc90371c77ff3a4bff4a30660ca264f4fff25095b76d8495fcff6517e674ee47b
+  metadata.gz: cbe1b66c813d0e35bd667a06e14bc68673655807d256771dac231ecb2f559660a05773267ef804e40f9d747482974d897b78c0df370340c55e7cfd290bdc4a41
+  data.tar.gz: 385b3ec651b1c2365392c7a1dddb0b7b63adddc6ade662f8ba7d72d6d49f025dff0b55490df6296181d361ac5792e888ed7db90c8b11b2129b5d6474fae2c8de

data/.gitignore

@@ -11,6 +11,7 @@
 /tmp/
 lib/extralite_ext.*
 Gemfile-bundle.lock
+Gemfile.lock
 /cmake-build-debug/
 CMakeLists.txt
 

data/.yardopts

@@ -5,4 +5,4 @@
 --no-private
 --exclude sqlite3_constants.rb
 ./lib
-./ext/extralite
+./ext/extralite/*.c

data/CHANGELOG.md

@@ -1,32 +1,47 @@
+# 2.7.1 2024-02-11
+
+- Fix API docs.
+
+# 2.7 2024-02-09
+
+- Improve progress handler API, add mode, period, tick options, global progress
+  handler. [#68](https://github.com/digital-fabric/extralite/pull/68)
+- Rework `Database#initialize` options
+- Add argv row mode (for passing column values as argv)
+- Streamline and improve query methods
+  [#67](https://github.com/digital-fabric/extralite/pull/67)
+- Implement row transforms
+
 # 2.6 2024-01-23
 
-- Implement changeset API
+- Implement changeset API.
   [#58](https://github.com/digital-fabric/extralite/issues/58)
-- Reorganize README, update benchmarks
+- Reorganize README, update benchmarks.
   [#63](https://github.com/digital-fabric/extralite/issues/63)
-- Implement progress handler API
+- Implement progress handler API.
   [#62](https://github.com/digital-fabric/extralite/issues/62)
-- Implement savepoint methods
+- Implement savepoint methods.
 
 # 2.5 2024-01-16
 
-- Update bundled sqlite to version 3.45.0
-- Implement `Database#batch_query` and related methods
+- Update bundled sqlite to version 3.45.0.
+- Implement `Database#batch_query` and related methods.
   [53](https://github.com/digital-fabric/extralite/issues/53)
-- Accept more options in `Database#initialize`
+- Accept more options in `Database#initialize`.
   [48](https://github.com/digital-fabric/extralite/issues/48)
-- Fix `Database#pragma` to return single value when reading pragma value
-- Accept database name in `Database#tables` method
+- Fix `Database#pragma` to return single value when reading pragma value.
+- Accept database name in `Database#tables` method.
 - Improve `Database#batch_execute` - now accepts Enumerable and Callable
-  parameters [52](https://github.com/digital-fabric/extralite/issues/52)
-- Rename `Database#execute_multi` to `Database#batch_execute`
-- Implement Query#clone
+  parameters. [52](https://github.com/digital-fabric/extralite/issues/52)
+- Rename `Database#execute_multi` to `Database#batch_execute`.
+- Implement `Query#clone`.
   [51](https://github.com/digital-fabric/extralite/issues/51)
-- Add support for GC compaction
-- Remove support for Ruby 2.7
-- Implement Query#<< [49](https://github.com/digital-fabric/extralite/issues/49)
-- Allow passing parameters in array
-- Add support for ractors
+- Add support for GC compaction.
+- Remove support for Ruby 2.7.
+- Implement `Query#<<`.
+  [49](https://github.com/digital-fabric/extralite/issues/49)
+- Allow passing parameters in array.
+- Add support for ractors.
   [#50](https://github.com/digital-fabric/extralite/issues/50)
 
 # 2.4 2023-12-24

data/Gemfile

@@ -1,3 +1,7 @@
 source 'https://rubygems.org'
 
 gemspec name: 'extralite'
+
+group :development do
+  gem "ruby_memcheck", "2.3.0" if Gem::Platform.local.os == "linux"
+end

data/Gemfile-bundle

@@ -2,4 +2,4 @@ source 'https://rubygems.org'
 
 gemspec name: 'extralite'
 
-gem "extralite-bundle", git: "file://#{File.expand_path(__dir__)}", ref: `git rev-parse --abbrev-ref HEAD`.strip
+gem 'extralite-bundle', git: "file://#{File.expand_path(__dir__)}", ref: `git rev-parse --abbrev-ref HEAD`.strip

data/README.md

@@ -3,7 +3,7 @@
   Extralite
 </h1>
 
-<h4 align="center">SQLite for Ruby</h4>
+<h4 align="center">Ruby on SQLite</h4>
 
 <p align="center">
   <a href="http://rubygems.org/gems/extralite">
@@ -26,7 +26,7 @@
 Extralite is a fast and innovative SQLite wrapper for Ruby with a rich set of
 features. It provides multiple ways of retrieving data from SQLite databases,
 makes it possible to use SQLite databases in multi-threaded and multi-fibered
-Ruby apps, and provides a comprehensive set of tools for managing SQLite
+Ruby apps, and includes a comprehensive set of tools for managing SQLite
 databases.
 
 Extralite comes in two flavors: the `extralite` gem which uses the
@@ -37,27 +37,33 @@ latest features and enhancements.
 
 ## Features
 
-- Best-in-class performance (up to 14X the performance of the
+- Best-in-class [performance](#performance) (up to 14X the performance of the
   [sqlite3](https://github.com/sparklemotion/sqlite3-ruby) gem).
 - Support for [concurrency](#concurrency) out of the box for multi-threaded
-  apps.
-- A variety of methods for retrieving data - hashes, array, single rows, single
-  values.
-- Support for external iteration, allowing iterating through single records or
-  batches of records.
-- Prepared queries.
-- Parameter binding.
-- Batch execution of queries.
-- Support for transactions and savepoints.
-- Support for loading [SQLite extensions](https://github.com/nalgeon/sqlean).
-- APIs for doing database backups.
-- Sequel adapter.
+  and multi-fibered apps.
+- A variety of ways to [retrieve data](#query-modes) - hashes, arrays, single
+  columns, single rows, [transforms](#value-transforms).
+- Support for [external iteration](#iterating-over-records-in-a-prepared-query),
+  allowing iterating through single records or batches of records.
+- [Prepared queries](#prepared-queries).
+- [Parameter binding](#parameter-binding).
+- [Batch execution](#batch-execution-of-queries) of queries.
+- [transactions and savepoints](#transactions-and-savepoints).
+- Advanced features: load [SQLite extensions](#loading-extensions), create
+  [backups](#creating-backups), retrieve [status
+  information](#retrieving-status-information), work with
+  [changesets](#working-with-changesets), interrogate [database
+  limits](#working-with-database-limits),  [trace](#tracing-sql-statements)
+  queries.
+- [Sequel](#usage-with-sequel) adapter.
 
 ## Table of Content
 
 - [Installing Extralite](#installing-extralite)
-- [Basic Usage](#basic-usage)
+- [Getting Started](#getting-started)
+- [Query Modes](#query-modes)
 - [Parameter binding](#parameter-binding)
+- [Value Transforms](#value-transforms)
 - [Data Types](#data-types)
 - [Prepared Queries](#prepared-queries)
 - [Batch Execution of Queries](#batch-execution-of-queries)
@@ -97,10 +103,9 @@ SQLite source code.
 Usage of the `extralite-bundle` gem is identical to the usage of the normal
 `extralite` gem, using `require 'extralite'` to load the gem.
 
-## Basic Usage
+## Getting Started
 
-Here's as an example showing how to open an SQLite database and run some
-queries:
+The following example shows how to open an SQLite database and run some queries:
 
 ```ruby
 db = Extralite::Database.new('mydb.sqlite')
@@ -126,24 +131,43 @@ db.query 'select * from foo' do |r|
 end
 ```
 
-Extralite also provides other ways of retrieving data:
+## Query Modes
+
+Extralite allows you to retrieve data from SQLite database in the form that most
+a particular context. For some use cases you'll want to work with rows as
+hashes. In other cases, you'll want to work with rows as arrays, or even as
+single values, if you're just reading one column.
+
+For that purpose, Extralite offers three different ways, or modes, of retrieving
+records:
+
+- `:hash`: read rows as hashes (this is the default mode).
+- `:ary`: read rows as arrays.
+- `:argv`: similar to the `:ary`, except that for queries with a single column,
+  the single column value is returned.
+
+Extralite provides separate methods for the different modes:
 
 ```ruby
-# get rows as arrays
-db.query_ary 'select * from foo'
-#=> [[1, 2, 3], [4, 5, 6]]
+# alias #query_hash
+db.query('select 1') #=> [{ "1" => 1 }]
 
-# get a single column
-db.query_single_column 'select x from foo'
-#=> [1, 4]
+db.query_ary('select 1') #=> [[1]]
 
-# get a single row
-db.query_single_row 'select * from foo order by x desc limit 1'
-#=> { x: 4, y: 5, z: 6 }
+db.query_argv('select 1') #=> [1]
+```
+
+Notice how all the return values above are arrays. This is because the different
+`#query_xxx` methods are designed to return multiple rows. If you want to just
+get back a single row, use one of the `query_single_xxx` methods:
+
+```ruby
+# alias #query_single_hash
+db.query('select 1') #=> { "1" => 1 }
+
+db.query_single_ary('select 1') #=> [1]
 
-# get a single value (a single column from a single row)
-db.query_single_value 'select z from foo order by x desc limit 1'
-#=> 6
+db.query_single_argv('select 1') #=> 1
 ```
 
 ## Parameter binding
@@ -157,14 +181,16 @@ statement:
 db.query('select x from my_table where y = ? and z = ?', 'foo', 'bar')
 ```
 
-You can also express place holders by specifying their index (starting from 1) using `?IDX`:
+You can also express place holders by specifying their index (starting from 1)
+using `?IDX`:
 
 ```ruby
 # use the same value for both place holders:
 db.query('select x from my_table where y = ?1 and z = ?1', 42)
 ```
 
-Another possibility is to use named parameters, which can be done by expressing place holders as `:KEY`, `@KEY` or `$KEY`:
+Another possibility is to use named parameters, which can be done by expressing
+place holders as `:KEY`, `@KEY` or `$KEY`:
 
 ```ruby
 db.query('select x from my_table where y = $y and z = $z', y: 'foo', z: 'bar')
@@ -223,6 +249,38 @@ db.execute(sql, Extralite::Blob.new('Hello, 世界!'))
 db.execute(sql, 'Hello, 世界!'.force_encoding(Encoding::ASCII_8BIT))
 ```
 
+## Value Transforms
+
+Extralite allows you to transform rows to any value your application may need by
+providing a transform proc that takes the raw row values and returns the
+transformed data. The transform proc is passed each resulting row either as a
+hash or as a list of values.
+
+Transforms are useful when you need to transform rows into ORM model instances,
+or when you need to do some other transformation on the values retrieved from
+the database.
+
+To transform results, pass a transform proc as the first parameter to one of the
+`#query_xxx` methods:
+
+```ruby
+transform = ->(h) { MyModel.new(h) }
+db.query(transform, 'select * from foo')
+#=> rows as instances of MyModel
+```
+
+When using the `argv` mode, the different column values are passed as individual
+values to the transform proc:
+
+```ruby
+transform = ->(a, b, c) { { a:a, b: b, c: JSON.parse(c) } }
+db.query_argv(transform, 'select a, b, c from foo')
+#=> transformed rows
+```
+
+Value transforms can also be done with [prepared
+queries](#value-transforms-in-prepared-queries).
+
 ## Prepared Queries
 
 Prepared queries (also known as prepared statements) allow you to maximize
@@ -240,7 +298,8 @@ query.bind(1).to_a
 
 ### Binding Values to Prepared Queries
 
-To bind parameter values to the query, use the `#bind` method. The parameters will remain bound to the query until `#bind` is called again.
+To bind parameter values to the query, use the `#bind` method. The parameters
+will remain bound to the query until `#bind` is called again.
 
 ```ruby
 query.bind(1)
@@ -261,23 +320,33 @@ query = db.prepare('select * from foo where x = ?', 1)
 
 ### Fetching Records from a Prepared Query
 
-Just like the `Database` interface, prepared queries offer various ways of
-retrieving records: as hashes, as arrays, as single column values, as a single
-value:
+Just like the `Database` interface, prepared queries support getting data using
+three different modes: as a hash, an array or as individual column values. To
+set the mode, you can use one of the `#prepare_xxx` methods:
 
 ```ruby
-# get records as arrays
-query.to_a_ary
+# hash mode
+db.prepare('select * from foo').to_a
+#=> [{ x: 1, y: 2, z: 3}]
+
+# argv mode
+db.prepare_argv('select x from foo').to_a
+#=> [1]
+
+# ary mode
+db.prepare_ary('select * from foo').to_a
 #=> [[1, 2, 3]]
+```
 
-# get records as single values
-query2 = db.prepare('select z from foo where x = ?', 1)
-query2.to_a_single_column
-#=> [3]
+You can also set the query mode by getting or setting `#mode`:
 
-# get a single value
-query2.next_single_column
-#=> 3
+```ruby
+q = db.prepare('select * from foo')
+q.to_a #=> [{ x: 1, y: 2, z: 3}]
+
+q.mode #=> :hash
+q.mode = :ary
+q.to_a "=> [[1, 2, 3]]
 ```
 
 ### Fetching Single Records or Batches of Records
@@ -299,12 +368,12 @@ query.next(10)
 #=> [{ x: 1, y: 2, z: 3 }, { x: 4, y: 5, z: 6 }]
 
 # Fetch the next row as an array
-query.reset
-query.next_ary
+query = db.prepare_ary('select * from foo')
+query.next
 #=> [1, 2, 3]
 
 # Fetch the next row as a single column
-db.prepare('select z from foo').next_single_column
+db.prepare_argv('select z from foo').next
 #=> 3
 ```
 
@@ -327,13 +396,16 @@ using the familiar `#each` method:
 
 ```ruby
 # iterate over records as hashes
+query = db.prepare('select * from foo')
 query.each { |r| ... }
 
 # iterate over records as arrays
-query.each_ary { |r| ... }
+query = db.prepare_ary('select * from foo')
+query.each { |r| ... }
 
 # iterate over records as single values
-query.each_single_column { |v| }
+query = db.prepare_argv('select a, b, c from foo')
+query.each { |a, b, c| ... }
 ```
 
 ### Prepared Query as an Enumerable
@@ -356,9 +428,33 @@ methods, such as `#map`, `#select`, `#inject`, `#lazy` etc. You can also
 instantiate an iterator explicitly:
 
 ```ruby
-# You need to pass the query to iterate over and the access mode (hash, ary, or
-# single_column):
-iterator = Extralite::Iterator(query, :hash)
+# You need to pass the query to iterate over:
+iterator = Extralite::Iterator(query)
+iterator.each { |r| ... }
+```
+
+### Value Transforms in Prepared Queries
+
+Prepared queries can automatically transform their result sets by setting a
+transform block. The transform block receives values according to the query mode
+(hash, array or argv). To set a transform you can pass a block to one of the
+`Database#prepare_xxx` methods, or use `Query#transform`:
+
+```ruby
+q = db.prepare('select * from items where id = ?') { |h| Item.new(h) }
+q.bind(42).next #=> Item instance
+
+# An equivalent
+q = db.prepare('select * from items where id = ?')
+q.transform { |h| Item.new(h) }
+```
+
+The same can be done for queries in `argv` or `ary` mode:
+
+```ruby
+db.prepare_argv('select * from foo') { |a, b, c| a + b + c }
+
+db.prepare_ary('select * from foo') { |a| a.map(&:to_s).join }
 ```
 
 ## Batch Execution of Queries
@@ -435,9 +531,8 @@ end
 #=> 2
 ```
 
-And of course, for your convenience there are also `#batch_query_ary` and
-`#batch_query_single_column` methods that retrieve records as arrays or as
-single values.
+The `#batch_query` method, like other row fetching methods, changes the row
+representation according to the query mode.
 
 ### Batch Execution of Prepared Queries
 
@@ -597,6 +692,12 @@ db.pragma(:journal_mode)
 #=> 'wal'
 ```
 
+You can also pass pragmas when opening the database:
+
+```ruby
+db = Extralite::Database.new('path/to/db', pragma: { foreign_keys: true })
+```
+
 ## Error Handling
 
 Extralite defines various exception classes that are raised when an error is
@@ -626,6 +727,18 @@ Extralite provides a comprehensive set of tools for dealing with concurrency
 issues, and for making sure that running queries on SQLite databases does not
 cause the app to freeze.
 
+**Note**: In order to allow concurrent access your the database, it is highly
+recommended that you set your database to use [WAL journaling
+mode](https://www.sqlite.org/wal.html) for *all* database connections.
+Otherwise, you risking running into performance problems and having queries fail
+with `BusyError` exceptions. You can easily open your database in WAL journaling
+mode by passing a `wal: true` option:
+
+```ruby
+# This will set PRAGMA journal_mode=1 and PRAGMA synchronous=1
+db = Extralite::Database.new('path/to/db', wal: true)
+```
+
 ### The Ruby GVL
 
 In order to support multi-threading, Extralite releases the [Ruby
@@ -701,9 +814,10 @@ db2.busy_timeout = 5
 db2.transaction { }
 ```
 
-For most use cases, setting the busy timeout solves the problem of failing to
-run queries because of a busy database, as normally transactions are
-short-lived.
+As stated above, setting the database to use WAL journaling mode greatly reduces
+contention between different process/threads accessing the same database. For
+most use cases, setting the busy timeout solves the problem of failing to run
+queries because of a busy database, as normally transactions are short-lived.
 
 However, in some cases, such as when running a multi-fibered app or when
 implementing your own timeout mechanisms, you'll want to set a [progress
@@ -711,7 +825,9 @@ handler](#the-progress-handler).
 
 ### Interrupting a Query
 
-To interrupt an ongoing query, use the `#interrupt` method. Normally this is done from a separate thread. Here's a way to implement a timeout using  `#interrupt`:
+To interrupt an ongoing query, use the `#interrupt` method. Normally this is
+done from a separate thread. Here's a way to implement a timeout using
+`#interrupt`:
 
 ```ruby
 def run_query_with_timeout(sql, timeout)
@@ -762,8 +878,7 @@ that specifies the approximate number of SQLite VM instructions between
 successive calls to the progress handler:
 
 ```ruby
-# Run progress handler every 100 SQLite VM instructions
-db.on_progress(100) do
+db.on_progress do
   check_for_timeout
   # Allow other threads to run
   Thread.pass
@@ -776,7 +891,7 @@ above, calling `#interrupt` causes the query to raise a
 `Extralite::InterruptError` exception:
 
 ```ruby
-db.on_progress(100) { db.interrupt }
+db.on_progress(period: 1) { db.interrupt }
 db.query('select 1')
 #=> Extralite::InterruptError!
 ```
@@ -785,7 +900,7 @@ You can also interrupt queries in progress by raising an exception. The query
 will be stopped, and the exception will propagate to the call site:
 
 ```ruby
-db.on_progress(100) do
+db.on_progress(period: 1) do
   raise 'BOOM!'
 end
 
@@ -797,7 +912,7 @@ Here's how a timeout might be implemented using the progress handler:
 
 ```ruby
 def setup_progress_handler
-  @db.on_progress(100) do
+  @db.on_progress do
     raise TimeoutError if Time.now - @t0 >= @timeout
     Thread.pass
   end
@@ -818,6 +933,65 @@ run_query_with_timeout(slow_sql, 5)
 #=> nil
 ```
 
+**Note**: you must not issue any query from within the progress handler.
+
+### Dealing with a Busy Database in the Progress Handler
+
+As mentioned above, the progress handler is also called when the database is
+busy, regardless of the progress period given to `#on_progress`. You can detect
+if the database is busy by checking the first argument passed to the progress
+handler, which will be true when busy:
+
+```ruby
+db.on_progress do |busy|
+  if busy
+    foo
+  else
+    bar
+  end
+end
+```
+
+This allows you to implement separate logic to deal with busy states, for
+example sleeping for a small period of time, or implementing a different timeout
+period.
+
+### Advanced Progress Handler Settings
+
+You can further tune the behaviour of the progress handler with the following
+options passed to `#on_progress`:
+
+- `:mode`: the following modes are supported:
+  - `:none` : the progress handler is disabled.
+  - `:normal`: the progress handler is called on query progress (this is the
+    default mode).
+  - `:once`: the progress handler is called once before running the query.
+  - `:at_least_once`: the progress handler is called once before running the
+    query, and on query progress.
+- `:period`: controls the approximate number of SQLite VM instructions executed
+  between consecutive calls to the progress handler. Default value: 1000.
+- `:tick`: controls the granularity of the progress handler. This is the value
+  passed internally to the SQLite library. Default value: 10.
+
+```ruby
+db.on_progress(mode: :at_least_once, period: 640, tick: 5) { snooze }
+```
+
+### Global Progress Handler Settings
+
+You can set the global progress handler behaviour by calling
+`Extralite.on_progress`. You can use this API to set the global progress
+settings, without needing to set a progress handler individually for each
+`Database` instance. This method takes the same options as
+`Database#on_progress`:
+
+```ruby
+Extralite.on_progress(mode: :at_least_once, period: 640, tick: 5) { snooze }
+
+# the new database instance uses the global progress handler settings
+db = Database.new(':memory:')
+```
+
 ### Extralite and Fibers
 
 The progress handler can also be used to switch between fibers in a
@@ -829,7 +1003,7 @@ handler. This will work for switching between fibers using either Polyphony or
 any fiber scheduler gem, such as Async et al:
 
 ```ruby
-db.on_progress(100) { sleep(0) }
+db.on_progress { sleep(0) }
 ```
 
 For Polyphony-based apps, you can also call `snooze` to allow other fibers to
@@ -837,7 +1011,7 @@ run while a query is progressing. If your Polyphony app is multi-threaded,
 you'll also need to call `Thread.pass` in order to allow other threads to run:
 
 ```ruby
-db.on_progress(100) do
+db.on_progress do
   snooze
   Thread.pass
 end
@@ -848,7 +1022,7 @@ use the regular `#move_on_after` and `#cancel_after` methods to implement
 timeouts for queries:
 
 ```ruby
-db.on_progress(100) { snooze }
+db.on_progress { snooze }
 
 cancel_after(3) do
   db.query(long_running_query)
@@ -868,7 +1042,14 @@ as long as the following conditions are met:
 
 ### Use with Ractors
 
-Extralite databases can safely be used inside ractors. Note that ractors are still an experimental feature of Ruby. A ractor has the benefit of using a separate GVL from the maine one, which allows true parallelism for Ruby apps. So when you use Extralite to access SQLite databases from within a ractor, you can do so without any considerations for what's happening outside the ractor when it runs queries.
+Extralite databases can safely be used inside ractors. A ractor has the benefit
+of using a separate GVL from the maine one, which allows true parallelism for
+Ruby apps. So when you use Extralite to access SQLite databases from within a
+ractor, you can do so without any considerations for what's happening outside
+the ractor when it runs queries.
+
+**Note**: Ractors are considered an experimental feature of Ruby. You may
+encounter errors or inconsistent behaviour when using ractors.
 
 ## Advanced Usage
 
@@ -1027,7 +1208,8 @@ large number of rows.
 
 ### Rows as Hashes
 
- [Benchmark source code](https://github.com/digital-fabric/extralite/blob/main/test/perf_hash.rb)
+[Benchmark source
+code](https://github.com/digital-fabric/extralite/blob/main/test/perf_hash.rb)
 
 |Row count|sqlite3 1.7.0|Extralite 2.5|Advantage|
 |-:|-:|-:|-:|
@@ -1037,7 +1219,8 @@ large number of rows.
 
 ### Rows as Arrays
 
-[Benchmark source code](https://github.com/digital-fabric/extralite/blob/main/test/perf_ary.rb)
+[Benchmark source
+code](https://github.com/digital-fabric/extralite/blob/main/test/perf_ary.rb)
 
 |Row count|sqlite3 1.7.0|Extralite 2.5|Advantage|
 |-:|-:|-:|-:|
@@ -1047,7 +1230,8 @@ large number of rows.
 
 ### Prepared Queries (Prepared Statements)
 
-[Benchmark source code](https://github.com/digital-fabric/extralite/blob/main/test/perf_hash_prepared.rb)
+[Benchmark source
+code](https://github.com/digital-fabric/extralite/blob/main/test/perf_hash_prepared.rb)
 
 |Row count|sqlite3 1.7.0|Extralite 2.5|Advantage|
 |-:|-:|-:|-:|
@@ -1058,7 +1242,10 @@ large number of rows.
 As those benchmarks show, Extralite is capabale of reading up to 2.4M rows per
 second, and can be more than 14 times faster than the `sqlite3` gem.
 
-Note that the benchmarks above were performed on synthetic data, in a single-threaded environment, with the GVL release threshold set to -1, which means that both Extralite and the `sqlite3` gem hold the GVL for the duration of the query.
+Note that the benchmarks above were performed on synthetic data, in a
+single-threaded environment, with the GVL release threshold set to -1, which
+means that both Extralite and the `sqlite3` gem hold the GVL for the duration of
+the query.
 
 ## License