tarantool-model 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb88c7317a6b38d448f89c6ca24ad43f2e7c4b3da9a936795fae74a966b4873e
-  data.tar.gz: c098a1157a2539596e6789d9717c883ed1d135f260d49b44d2018e1b42f53243
+  metadata.gz: dfebd43ac5f258976a8257dae17d23a26a607534c97c83303dc020f8fc7d3e82
+  data.tar.gz: 8aee6cf2bfc9c2e16dee2440ebfb4292f6458eeacb355ebe4a40bebdb5d8a43b
 SHA512:
-  metadata.gz: 16b134ac4b0b0efe415455fcd09b4e314bc5ac91ed5e0408cac646298ce49a78d59ce86d74afe981edc9b0c4aacf2bb1ce395206912151e67c637555537d6303
-  data.tar.gz: f9bf98de1e3c83bae3ccf399965e877887556683b8575fc54aa8ac75af2adf53412ee0af175d24dc4e589b01bf564652240cf00c0eab2ebabcbe574f6e515f06
+  metadata.gz: 8a4161e4bbf0f5593ef3d0a0b2cc8b2a2b49c5456466e4e1252e8ffccb8ec497a10c455fb2389da59f5dd0b30e4c0a5baaec3bd400a1d91174f7158c2520e9d3
+  data.tar.gz: 953f19659c46174dd935642bb8f99a4d846cc7dc892f9c7bbc992ee5e1272851a7d1526edfbec71ce1ec6581778a273ec86f5cd94cbee0b73086e6f253c0ef40

data/CHANGELOG.md

@@ -1,6 +1,21 @@
 # Changelog
 
-## 0.1.0 (unreleased)
+## 0.3.0 (2026-10-17)
+
+- `Tarantool::Model.default_storage`: a storage, or a Proc called once on first use, for models without one of
+  their own.
+- Optimistic locking on the `locking_column` attribute (`lock_version` by default): update and destroy compare
+  the stored version with the record's and bump it, in a transaction on `Storage::Box`; `StaleObjectError`.
+- Storages answer `supports_transactions?`.
+
+## 0.2.0 (2026-10-17)
+
+- `Storage::Box` converts rows with tarantool-client (`as: :row`), by the format of the schema each request ran against, and no longer looks up `space_info` before every operation.
+- `Testing::MemoryStorage` (`require 'tarantool/model/testing'`): in-memory storage for application tests that
+  keeps the `Storage::Box` or `Storage::Crud` contract, with spaces declared in tarantool-schema's format.
+- Depends on `tarantool-client ~> 0.2.0`.
+
+## 0.1.0 (2026-10-16)
 
 First release.
 

data/README.md

@@ -22,19 +22,14 @@ require 'tarantool/model'
 ```ruby
 pool = Tarantool::Client::Pool.new(['tcp://app:secret@db1:3301', 'tcp://app:secret@db2:3301'])
 
-module ApplicationModel
-  def self.included(base)
-    base.include Tarantool::Model
-    base.storage = Tarantool::Model::Storage::Box.new(
-      pool,
-      read:  { mode: :prefer_ro },
-      write: { mode: :rw }
-    )
-  end
-end
+Tarantool::Model.default_storage = Tarantool::Model::Storage::Box.new(
+  pool,
+  read:  { mode: :prefer_ro },
+  write: { mode: :rw }
+)
 
 class User
-  include ApplicationModel
+  include Tarantool::Model
 
   attribute :id,    :integer
   attribute :email, :string
@@ -44,6 +39,10 @@ class User
 end
 ```
 
+`Tarantool::Model.default_storage` serves every model that sets no `storage` of its own; `User.storage = ...`
+overrides it per model. A Proc assigned to it (`Tarantool::Model.default_storage = -> { build_storage }`) is
+called once, on first use, so the connection is opened only when a model needs it.
+
 `Storage::Box` passes its `read:`/`write:` options verbatim to the client's read and write requests. The `Pool`
 routing `mode:` (symbols like `:prefer_ro`, `:rw`; requires a `Pool` as transport) is one example; `timeout:` works
 too. `Storage::Crud` takes no `read:`/`write:`: crud defaults are set on `Tarantool::Crud::Client.new(..., read:,
@@ -105,6 +104,9 @@ Callbacks: `before_validation`, `after_validation`, `before_save`, `around_save`
 `before_create`, `around_create`, `after_create`, `before_update`, `around_update`, `after_update`,
 `before_destroy`, `around_destroy`, `after_destroy`.
 
+Models talk to Tarantool through the client given to their storage, so the client's `instrumenter:` and
+`logger:` report every read and write; see the tarantool-client README.
+
 ### Counters
 
 ```ruby
@@ -116,6 +118,33 @@ user.decrement!(:age)
 Counters skip validations and callbacks. Only the counter attribute and the raw tuple are refreshed from the
 response; other unsaved changes on the record survive. Raises `RecordNotFound` if the row is gone.
 
+### Optimistic locking
+
+```ruby
+class Account
+  include Tarantool::Model
+
+  attribute :id,           :integer
+  attribute :balance,      :decimal
+  attribute :lock_version, :integer, default: 0
+end
+
+Account.locking_column            # => :lock_version
+Account.locking_column = :version # another attribute, or nil to disable
+```
+
+Locking is on when `locking_column` names a declared attribute; the space needs that field. A nil version is
+stored as 0 on create. On update, the row is read again and its version compared with the record's (a value
+assigned by hand, for example from a form field, counts); a different version raises `StaleObjectError`, and so
+does a row changed underneath on destroy. The update sends the changed attributes plus the version incremented
+by one, and the record picks the new version up. Only the version changed sends nothing.
+
+On `Storage::Box` the check and the update run in one transaction (MVCC must be on, as for `transaction`), so a
+concurrent commit on the same row between them surfaces as `StaleObjectError` too. Inside `Model.transaction` no
+second transaction is opened; the check joins the open one. `Storage::Crud` has no transactions: the check runs
+unguarded, and a write between the read and the update goes unnoticed. Counters (`increment!`, `decrement!`)
+bypass locking and leave the version alone.
+
 ## Querying
 
 ```ruby
@@ -205,17 +234,95 @@ by key with crud `get` and does not use it. Make sure the index name matches the
 Keyset pagination with `after` requires a tuple, which `select` returns but single-row operations (`find`,
 `find_by`) do not. Calling `after` on a record loaded with `find` raises `ArgumentError`.
 
+## Testing
+
+`Tarantool::Model::Testing::MemoryStorage` keeps rows in memory, so model specs run without a Tarantool server.
+It is loaded only on request:
+
+```ruby
+# spec/spec_helper.rb
+require 'tarantool/model/testing'
+
+USERS_SPACE = {
+  format: [{ name: :id, type: :unsigned }, { name: :email, type: :string },
+           { name: :age, type: :unsigned, is_nullable: true }],
+  indexes: [{ name: :primary, parts: [:id], sequence: true },
+            { name: :email, parts: [:email] },
+            { name: :age, parts: [:age], unique: false }]
+}.freeze
+
+RSpec.configure do |config|
+  config.before do
+    User.storage = Tarantool::Model::Testing::MemoryStorage.new({ users: USERS_SPACE })
+  end
+end
+```
+
+Build a new storage for every example; separate instances share nothing.
+
+Spaces are declared like the `ensure_space` arguments of tarantool-schema: `format` entries are
+`{ name:, type:, is_nullable: }`; `indexes` is an Array of `{ name:, parts:, unique:, type:, sequence: }` and the
+first one is primary; `unique` defaults to true and `type` to `tree`. Parts are field names or
+`{ field:, type:, is_nullable: }`. Unknown keys and types raise `ArgumentError`, and so do indexes Tarantool
+refuses to create: a non-unique primary or `hash` index, a nullable part in either. Spaces are passed as one Hash,
+`MemoryStorage.new({ users: SCHEMA, accounts: OTHER }, behaves_like: :crud)`; `behaves_like:` is the only keyword.
+A tarantool-schema definition can be passed as is: `MemoryStorage.from_definition(definition)` duck-types
+`definition.to_h`.
+
+`behaves_like: :box` (default) keeps the `Storage::Box` contract; `behaves_like: :crud` keeps the
+`Storage::Crud` one. What Tarantool would reject is raised with the class the application gets in production:
+
+| Situation | `:box` | `:crud` |
+|---|---|---|
+| duplicate unique key | `RecordNotUnique` | `RecordNotUnique` |
+| nil in a non-nullable field | `Tarantool::ServerError`, code 23 | `Tarantool::Crud::InsertError` / `UpdateError` |
+| update of a primary key field | `Tarantool::ServerError`, code 94 | `Tarantool::Crud::UpdateError` |
+| `+`/`-` on a non-number | `Tarantool::ServerError`, code 26 | `Tarantool::Crud::UpdateError` |
+| key with more parts than the index | `Tarantool::ServerError`, code 31 | — |
+| `get` by a key without every primary key part | first matching row | `Tarantool::Crud::GetError` |
+| partial key on a multi-part hash index | `Tarantool::ServerError`, code 136 | — |
+| unsupported iterator or `after` on a hash index | `Tarantool::ServerError`, code 112 | — |
+| unknown space | `Tarantool::SchemaError` | `Tarantool::Crud::<Operation>Error` |
+| `count` | `NotSupportedError` | counts |
+| `transaction` | rolls back when the block raises | `NotSupportedError` |
+| `supports_transactions?` | `true` | `false` |
+| single-row results | with a tuple | `tuple` is nil |
+
+`verify` (the schema check `Storage::Box` runs on first use) does nothing in `:crud` mode. A nil primary key gets
+the next sequence value when the primary index has `sequence: true` (`:box` only). `transaction` accepts
+`isolation:` and `timeout:` and ignores them. In `:crud` mode a missing `bucket_id` is filled from the primary key:
+the same key always gets the same value, but not the bucket vshard would compute. Values, keys and `after` tuples
+are copied through the client's msgpack codec, so they behave as on the wire: Symbols become Strings (incl. Hash
+keys in any/map fields), and changing a returned value never changes the store.
+
+Not modelled:
+
+- value types: only nullability is checked, so a String in an `unsigned` field is stored;
+- update operators other than `=`, `+` and `-` (`NotSupportedError`);
+- MVCC and concurrency: writes are visible at once, and a transaction is a snapshot restored on error;
+- Strings compare bytewise like Tarantool's default collation; values of different classes in one index raise
+  `ArgumentError`;
+- a `hash` index walks in key order, Tarantool's order is unspecified;
+- `get`, `update` and `delete` match primary keys by Ruby equality, so `[1.0]` does not find a row stored as `[1]`,
+  while Tarantool does;
+- in `:crud` mode, a condition through a name that is a field but not an index: crud filters by that field,
+  MemoryStorage returns nothing;
+- JSON path parts, `rtree` and `bitset` indexes (`ArgumentError`);
+- thread safety.
+
 ## Rails
 
 `to_param` joins a composite key with `-` (e.g. `"7-1"`) for route helpers. `as_json` works through
 `ActiveModel::Serializers::JSON`. `form_with` works with any persisted model.
 
-There is no Railtie. Configure storage in an initializer:
+`tarantool-rails` configures the storage from `config/tarantool.yml`. Without it, set
+`Tarantool::Model.default_storage` in an initializer:
 
 ```ruby
 # config/initializers/tarantool.rb
 pool = Tarantool::Client::Pool.new(Rails.application.config.tarantool_uris)
-User.storage = Tarantool::Model::Storage::Box.new(pool, read: { mode: :prefer_ro }, write: { mode: :rw })
+Tarantool::Model.default_storage =
+  Tarantool::Model::Storage::Box.new(pool, read: { mode: :prefer_ro }, write: { mode: :rw })
 ```
 
 ## Errors
@@ -229,6 +336,7 @@ Tarantool::Model::Error
 ├── RecordInvalid             # #record
 ├── RecordNotSaved            # #record; a before callback aborted
 ├── RecordNotUnique           # duplicate primary or unique secondary key
+├── StaleObjectError          # #record, #attempted_action; the row's version changed since the record was loaded
 ├── SchemaMismatchError       # attribute or primary key does not match the space format
 ├── NotSupportedError         # operation not available for this storage (e.g. count on Storage::Box)
 └── TransactionMismatchError  # write through a storage that has no open transaction in the current fiber
@@ -260,8 +368,8 @@ TARANTOOL_MODEL_CRUD_URI=tcp://app:secret@localhost:3332 bundle exec rspec --tag
 
 ## Public API
 
-`Tarantool::Model`, `Storage::Box`, `Storage::Crud`, `Types::UUID`, `Types::Interval`, `Types::Binary`,
-`Relation`, and the error classes above.
+`Tarantool::Model`, `Storage::Box`, `Storage::Crud`, `Testing::MemoryStorage`, `Types::UUID`, `Types::Interval`,
+`Types::Binary`, `Relation`, and the error classes above.
 
 Everything else, including anything tagged `@api private` in its source comment, is an implementation detail
 and may change in any release.

data/lib/tarantool/model/errors.rb

@@ -35,6 +35,17 @@ module Tarantool
       end
     end
 
+    # The row's locking column changed since the record was loaded.
+    class StaleObjectError < Error
+      attr_reader :record, :attempted_action
+
+      def initialize(record, attempted_action)
+        @record = record
+        @attempted_action = attempted_action
+        super("Attempted to #{attempted_action} a stale #{record.class.name} with key #{record.to_key.inspect}")
+      end
+    end
+
     class RecordNotUnique < Error; end
     class SchemaMismatchError < Error; end
     class TransactionMismatchError < Error; end

data/lib/tarantool/model/locking.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Model
+    # Optimistic locking on the attribute named by locking_column, when the model declares it. An update compares
+    # the stored version with the record's and bumps it, inside a transaction on storages that have them, so a
+    # concurrent commit on the same row surfaces as StaleObjectError instead of being overwritten.
+    module Locking
+      extend ActiveSupport::Concern
+
+      ER_TRANSACTION_CONFLICT = 97
+      private_constant :ER_TRANSACTION_CONFLICT
+
+      included do
+        class_attribute :locking_column, instance_accessor: false, default: :lock_version
+      end
+
+      class_methods do
+        def locking_enabled?
+          !locking_column.nil? && attribute_names.include?(locking_column.to_s)
+        end
+      end
+
+      private
+
+      def create_row
+        public_send("#{locking_column}=", 0) if locking_enabled? && public_send(locking_column).nil?
+
+        super
+      end
+
+      def update_pending?
+        return super unless locking_enabled?
+
+        changes.except(locking_column.to_s).any?
+      end
+
+      def updated_row
+        return super unless locking_enabled?
+
+        atomically(:update) do
+          locked_row(:update) || raise(RecordNotFound.new(self.class, key_in_database))
+
+          write_row(locked_operations)
+        end
+      end
+
+      def delete_row
+        return super unless locking_enabled? && persisted?
+
+        atomically(:destroy) do
+          locked_row(:destroy)
+
+          super()
+        end
+      end
+
+      def locked_operations
+        column = locking_column.to_s
+        operations = update_operations.reject { |(_operator, name, _value)| name == column }
+
+        operations << ['=', column, public_send(locking_column).to_i + 1]
+      end
+
+      # The row, or nil when it is gone; a version other than the record's raises.
+      def locked_row(action)
+        row = space_storage.get(space_name, key_in_database)
+        raise StaleObjectError.new(self, action) if row && row.attributes[locking_column] != public_send(locking_column)
+
+        row
+      end
+
+      # Inside an open Model.transaction the check joins it; without transactions (crud) it runs unguarded.
+      def atomically(action, &)
+        storage = writing_storage
+        return yield if Transactions.handle(storage) || !storage.supports_transactions?
+
+        storage.transaction(&)
+      rescue Tarantool::ServerError => e
+        raise StaleObjectError.new(self, action) if e.code == ER_TRANSACTION_CONFLICT
+
+        raise
+      end
+
+      def locking_column = self.class.locking_column
+
+      def locking_enabled? = self.class.locking_enabled?
+    end
+  end
+end

data/lib/tarantool/model/persistence.rb

@@ -80,15 +80,23 @@ module Tarantool
         raise ArgumentError, "the primary key of a persisted #{self.class.name} cannot change" if primary_key_changed?
 
         run_callbacks(:update) do
-          written(updated_row) if changed?
+          written(updated_row) if update_pending?
 
           true
         end
       end
 
+      def update_pending? = changed?
+
       def updated_row
-        operations = changes.map { |name, (_was, value)| ['=', name, value] }
+        write_row(update_operations)
+      end
+
+      def update_operations
+        changes.map { |name, (_was, value)| ['=', name, value] }
+      end
 
+      def write_row(operations)
         writing_storage.update(space_name, key_in_database, operations) ||
           raise(RecordNotFound.new(self.class, key_in_database))
       end

data/lib/tarantool/model/settings.rb

@@ -7,13 +7,22 @@ module Tarantool
       extend ActiveSupport::Concern
 
       included do
-        class_attribute :storage, instance_accessor: false
         class_attribute :primary_key, instance_accessor: false, default: :id
         # @api private
+        class_attribute :_storage, instance_accessor: false
+        # @api private
         class_attribute :_space_name, instance_accessor: false
       end
 
       class_methods do
+        def storage
+          _storage || Tarantool::Model.default_storage
+        end
+
+        def storage=(storage)
+          self._storage = storage
+        end
+
         def space_name
           _space_name || model_name.plural
         end

data/lib/tarantool/model/storage/box/layout.rb

@@ -4,8 +4,7 @@ module Tarantool
   module Model
     module Storage
       class Box
-        # Field order of a space: converts attribute Hashes to tuples and back, and checks a model against the
-        # format. Fields the model does not declare go out as nil and are ignored on read.
+        # Checks a model against the space format.
         # @api private
         class Layout
           def initialize(space_info)
@@ -13,14 +12,6 @@ module Tarantool
             @names = space_info.fields.map { |field| field.name.to_sym }
           end
 
-          def to_tuple(attributes)
-            @names.map { |name| attributes[name] }
-          end
-
-          def to_row(tuple)
-            Row.new(attributes: @names.zip(tuple).to_h, tuple:)
-          end
-
           def verify!(attributes:, primary_key:)
             missing = attributes - @names
             raise SchemaMismatchError, "space #{@space_info.name} has no field #{missing.join(', ')}" if missing.any?

data/lib/tarantool/model/storage/box.rb

@@ -4,9 +4,9 @@ module Tarantool
   module Model
     module Storage
       # Storage over a Tarantool::Client or Client::Pool. `read` options go to get and select, `write` options
-      # to insert, update and delete, verbatim. The format comes from the client's schema on every call, so
-      # alter and reconnect are picked up without a cache here. Inside Model.transaction operations, including
-      # space_info, go through the open stream.
+      # to insert, update and delete, verbatim. The client converts tuples by the format of the schema each request
+      # ran against, so alter and reconnect are picked up without a cache here. Inside Model.transaction operations,
+      # including space_info, go through the open stream.
       class Box
         ER_TUPLE_FOUND = 3
         private_constant :ER_TUPLE_FOUND
@@ -22,43 +22,30 @@ module Tarantool
         end
 
         def verify(space, attributes:, primary_key:)
-          layout(space, read).verify!(attributes:, primary_key:)
+          Layout.new(client.space_info(space, **read.slice(:mode, :timeout))).verify!(attributes:, primary_key:)
         end
 
         def get(space, key)
-          layout = layout(space, read)
-          tuple = client.select(space, key, limit: 1, **read).first
-
-          tuple && layout.to_row(tuple)
+          row(client.select(space, key, limit: 1, as: :row, **read).first)
         end
 
         def insert(space, attributes)
-          layout = layout(space, write)
-          tuple = unique { client.insert(space, layout.to_tuple(attributes), **write) }
-
-          layout.to_row(tuple)
+          row(unique { client.insert(space, attributes, as: :row, **write) })
         end
 
         def update(space, key, operations)
-          layout = layout(space, write)
-          tuple = unique { client.update(space, key, operations, **write) }
-
-          tuple && layout.to_row(tuple)
+          row(unique { client.update(space, key, operations, as: :row, **write) })
         end
 
         def delete(space, key)
-          layout = layout(space, write)
-          tuple = client.delete(space, key, **write)
-
-          tuple && layout.to_row(tuple)
+          row(client.delete(space, key, as: :row, **write))
         end
 
         def select(space, index:, key:, iterator:, limit:, after:)
-          layout = layout(space, read)
-          options = { index: index || 0, iterator:, after:, **read }
+          options = { index: index || 0, iterator:, after:, as: :row, **read }
           options[:limit] = limit if limit
 
-          client.select(space, key, **options).map { |tuple| layout.to_row(tuple) }
+          client.select(space, key, **options).map { |found| row(found) }
         end
 
         # IPROTO has no count request, and calling box.space.X.index.Y:count needs execute grants
@@ -67,6 +54,8 @@ module Tarantool
           raise NotSupportedError, 'Storage::Box does not count'
         end
 
+        def supports_transactions? = true
+
         def transaction(**options, &block)
           @caller.transaction(**options) do |stream|
             Transactions.open(self, stream, &block)
@@ -91,8 +80,8 @@ module Tarantool
           Transactions.handle(self) ? options.except(:mode) : options
         end
 
-        def layout(space, options)
-          Layout.new(client.space_info(space, **options.slice(:mode, :timeout)))
+        def row(found)
+          found && Row.new(attributes: found.attributes, tuple: found.tuple)
         end
 
         def unique

data/lib/tarantool/model/storage/crud.rb

@@ -48,6 +48,8 @@ module Tarantool
           @crud.space(space).count(conditions(index, key, iterator))
         end
 
+        def supports_transactions? = false
+
         def transaction(**)
           raise NotSupportedError, 'crud has no interactive transactions'
         end

data/lib/tarantool/model/testing/memory_storage/box_mode.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Model
+    module Testing
+      class MemoryStorage
+        # Storage::Box behaviour: schema checks, a tuple on every row, transactions, no count, server errors.
+        # @api private
+        class BoxMode
+          def verify(attributes:, primary_key:)
+            yield.layout.verify!(attributes:, primary_key:)
+          end
+
+          def sequences? = true
+
+          def transaction! = nil
+
+          def supports_transactions? = true
+
+          def get(space, key)
+            space.get(key)
+          end
+
+          def to_tuple(space, attributes)
+            space.info.to_tuple(attributes)
+          end
+
+          def row(space, tuple, **)
+            Row.new(attributes: space.info.to_hash(tuple), tuple:)
+          end
+
+          def count!
+            raise NotSupportedError, 'MemoryStorage behaves like Storage::Box, which does not count'
+          end
+
+          def scan(space, **)
+            space.scan(**)
+          end
+
+          def error(violation, _operation)
+            return Tarantool::SchemaError.new(violation.message) if %i[space index].include?(violation.kind)
+
+            Tarantool::ServerError.new(violation.message, code: violation.code)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/model/testing/memory_storage/crud_mode.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Model
+    module Testing
+      class MemoryStorage
+        # Storage::Crud behaviour: no schema check, count, no transactions, no tuple on single-row results, no
+        # sequences, bucket_id filled in, and the tarantool-crud error class of each operation.
+        # @api private
+        class CrudMode
+          BUCKET_ID = 'bucket_id'
+          BUCKET_COUNT = 30_000
+          FLATTEN = 'Failed to flatten object: FlattenError: Object is specified in bad format: FlattenError: ' \
+                    'Field "%s" isn\'t nullable (set skip_nullability_check_on_flatten option to true to skip check)'
+
+          def verify(**) = nil
+
+          def count! = nil
+
+          def transaction!
+            raise NotSupportedError, 'crud has no interactive transactions'
+          end
+
+          def sequences? = false
+
+          def supports_transactions? = false
+
+          def get(space, key)
+            parts = space.info.primary_index.parts.size
+            raise Violation.exact_match(parts, key.size) unless key.size == parts
+
+            space.get(key)
+          end
+
+          def to_tuple(space, attributes)
+            tuple = space.info.to_tuple(attributes)
+            fieldno = space.info.fields.index { |field| field.name == BUCKET_ID }
+            tuple[fieldno] ||= bucket(space, tuple) if fieldno
+
+            tuple
+          end
+
+          def row(space, tuple, single:)
+            Row.new(attributes: space.info.to_hash(tuple), tuple: single ? nil : tuple)
+          end
+
+          # Without a condition crud scans the primary index. With one, crud reads a name that is not an index as a
+          # field name and filters by that field; this returns nothing instead, as crud does for a name that is
+          # neither.
+          def scan(space, index:, key:, iterator:, after:)
+            return space.scan(index: nil, key: [], iterator: :all, after:) if iterator == :all || key.empty?
+            return [] unless space.index?(index)
+
+            space.scan(index:, key:, iterator:, after:)
+          end
+
+          def error(violation, operation)
+            raise Error, "tarantool-crud is not loaded; require 'tarantool/crud'" unless defined?(Tarantool::Crud)
+
+            Tarantool::Crud.const_get("#{operation.capitalize}Error").new(message(violation, operation))
+          end
+
+          private
+
+          def bucket(space, tuple)
+            key = space.info.primary_index.parts.map { |part| tuple[part.fieldno] }
+
+            (Zlib.crc32(Marshal.dump(key)) % BUCKET_COUNT) + 1
+          end
+
+          def message(violation, operation)
+            return %(Space "#{violation.subject}" doesn't exist) if violation.kind == :space
+            return format(FLATTEN, violation.subject) if violation.kind == :nil_field && operation == :insert
+
+            "Failed to #{operation}: #{violation.message}"
+          end
+        end
+      end
+    end
+  end
+end