elasticsearch_record 1.8.2 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bbb80c1852041338e02e17314a2a70e852db077e2724383fe05d1990dc5c601e
-  data.tar.gz: 5d1f2b445e83e602b16ac571b8b3824784490f9c365a304b4be06aaa02620cb2
+  metadata.gz: df21aa38516f4e56830e16ffcff4164b65541a869e3964771771eacdf4e8ad16
+  data.tar.gz: 7ba579e28c1a85e7f890654c99c675eb60dd2fddf1b1eb877b0967e17f1d7097
 SHA512:
-  metadata.gz: 80ac0419ba02c1d7cc563446067caff43f7ee5b1a92c1155b5d3c2871652b06d5a8998aae4da6ee5c44289c7579a87b1346c15ae15630c11ab8cded34412e524
-  data.tar.gz: 1559d1ab3873e002c867c88726358a4d1c3f875e087f8b37ec58d9c8ee196fc757490c246409c1bc32871e9210b617e6c48473c7fe6fe68e97ab47e66da010ec
+  metadata.gz: cb521dc265ec3a517ebda7b8b6e60b5471b1411bd8f04d6be72098e95177e32af06267bc9a2e2881699d0f7f317c3bf1ef77b6613d9657df6ac7347affa80cf9
+  data.tar.gz: 981b0955f21d2260d794cc1946ed560fa70d0e429b5c0bc97d2c9c5b29b396af471cd8d6460929fa451913ad44f7d9992c9b8c0d8a6cd6a7035c338147161138

data/Gemfile

@@ -4,3 +4,10 @@ source "https://rubygems.org"
 
 # Specify your gem's dependencies in elasticsearch_record.gemspec
 gemspec
+
+# Pin the Elasticsearch client to the 8.x line for local development & specs.
+# The gemspec intentionally allows '>= 7.17', but the 9.x client sends an
+# 'Accept: application/vnd.elasticsearch+json; compatible-with=9' header that
+# 8.x servers reject with a media_type_header_exception (HTTP 400).
+# Keep this in sync with the server you develop against.
+gem 'elasticsearch', '~> 8.0'

data/README.md

@@ -6,6 +6,8 @@
 [![Gem Version](https://badge.fury.io/rb/elasticsearch_record.svg)](https://badge.fury.io/rb/elasticsearch_record)
 [![License](https://img.shields.io/github/license/ruby-smart/elasticsearch_record)](docs/LICENSE)
 
+[![Coverage Status](https://coveralls.io/repos/github/ruby-smart/elasticsearch_record/badge.svg?branch=main&kill_cache=1)](https://coveralls.io/github/ruby-smart/elasticsearch_record?branch=main)
+
 ActiveRecord adapter for Elasticsearch
 
 _ElasticsearchRecord is a ActiveRecord adapter and provides similar functionality for Elasticsearch._
@@ -14,10 +16,11 @@ _ElasticsearchRecord is a ActiveRecord adapter and provides similar functionalit
 
 **PLEASE NOTE:**
 
-- This is the `main`-branch, which currently supports rails **7.1** _(see section 'Rails_Versions' for supported versions)_
-- supports ActiveRecord ~> 7.1 + Elasticsearch >= 7.17
-- added features up to Elasticsearch `8.16.1`
-- tested with Elasticsearch `8.15.2`
+- This is the `main`-branch, which supports rails **7.2** _(see section 'Rails_Versions' for supported versions)_
+- supports ActiveRecord ~> 7.2 + Elasticsearch >= 7.17
+- added features up to Elasticsearch `8.17.1` _(tested against `8.19.14`)_
+- _ES|QL_ queries _(`TYPE_ESQL` / the `esql.query` gate)_ require **Elasticsearch >= 8.11**, where the feature became
+  generally available. All other features remain available from Elasticsearch `7.17`.
 
 -----
 
@@ -25,6 +28,13 @@ _ElasticsearchRecord is a ActiveRecord adapter and provides similar functionalit
 
 Supported rails versions:
 
+### Rails 7.2:
+_(since gem version 2.1)_
+
+https://github.com/ruby-smart/elasticsearch_record/tree/rails-7-2-stable
+
+[![rails-7-1-stable](https://img.shields.io/badge/rails-7.2.stable-orange.svg)](https://github.com/ruby-smart/elasticsearch_record/tree/rails-7-2-stable)
+
 ### Rails 7.1:
 _(since gem version 1.8)_
 
@@ -46,11 +56,11 @@ https://github.com/ruby-smart/elasticsearch_record/tree/rails-7-0-stable
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'elasticsearch_record', '~> 1.8'
+gem 'elasticsearch_record'
 
 # alternative
 gem 'elasticsearch_record', git: 'https://github.com/ruby-smart/elasticsearch_record', branch: 'rails-7-1-stable'
-gem 'elasticsearch_record', git: 'https://github.com/ruby-smart/elasticsearch_record', branch: 'rails-70-stable'
+gem 'elasticsearch_record', git: 'https://github.com/ruby-smart/elasticsearch_record', branch: 'rails-7-0-stable'
 
 ```
 
@@ -62,6 +72,78 @@ Or install it yourself as:
 
     $ gem install elasticsearch_record
 
+-----
+
+## Upgrading to 2.0
+
+Version **2.0** contains breaking changes. Coming from **1.8.x**, check the following:
+
+### 1. Table (index) names are resolved by default
+
+Every table statement now resolves its name through `#_env_table_name`, so the
+`table_name_prefix` / `table_name_suffix` no longer have to be applied by hand in migrations or database statements
+_(which silently wrote into another environment's index)_.
+
+```ruby
+# 1.8.x - the prefix / suffix had to be applied manually
+drop_table _env_table_name("settings")
+
+# 2.0 - resolved on its own
+drop_table "settings"
+```
+
+Existing migrations keep working - `_env_table_name` is idempotent and still public, so a
+hand-resolved name resolves to the very same index. A new `decorate:`-argument opts out per
+call, and `ElasticsearchRecord.decorate_table_names` acts as a global kill-switch.
+
+_see @ [environment-related-table-name](#environment-related-table-name), [opting out with `decorate: false`](#opting-out-with-decorate-false) & [global kill-switch](#global-kill-switch)_
+
+### 2. `select` raises on metadata fields
+
+Metadata fields _(`_id`, `_score`, `_index`, ...)_ are not part of the `_source` node, so they
+could never be resolved through the `_source`-filter this method builds - providing them
+silently created a filter that never matched.
+
+```ruby
+Search.select(:_id)
+# => ActiveRecord::UnknownAttributeReference
+```
+
+They are returned anyway and accessible on each record _(`Search.first._id`)_. To resolve the
+metadata **without** transferring the `_source`, use the new `#meta_only!` method.
+
+### 3. `restore_table` replaces its `open:`-argument with `unblock:`
+
+A restore runs through a `clone`, so the restored table **inherits** the 'write'-block of its
+source - the table was open, but read-only. `unblock:` _(default: `true`)_ releases it again.
+`ModelApi#restore!` follows along.
+
+```ruby
+# 1.8.x
+restore_table 'settings', from: 'settings-snapshot-2024', open: true
+
+# 2.0
+restore_table 'settings', from: 'settings-snapshot-2024', unblock: true
+```
+
+### 4. The plural table statements no longer skip AR-internal indices
+
+`#open_tables`, `#close_tables`, `#refresh_tables` & `#truncate_tables` no longer subtract the
+ActiveRecord-internal indices _(`schema_migrations` & `ar_internal_metadata`)_ - an explicitly
+named index was silently dropped from the list. They now return an `Array` with an entry for
+**every** provided name.
+
+### 5. `truncate_table` raises for AR-internal indices
+
+The statement runs a `drop` & `create` and would wipe the migration state.
+`#drop_table` stays unguarded by design _(ActiveRecord resets both tables through it)_.
+
+### 6. `esql` & `msearch` dropped their `async:`-argument
+
+Both dispatch through the public `exec_query` now, since rails 7.1 made `internal_exec_query`
+private - the `async:`-argument was dropped along with it.
+
+-----
 
 ## Features
 * ActiveRecord's `create, read, update & delete` behaviours
@@ -71,6 +153,8 @@ Or install it yourself as:
   * additional relation methods to find records with `filter, must, must_not, should`
   * aggregated queries with Elasticsearch `aggregation` methods
   * resolve search response `hits`, `aggregations`, `buckets`, ... instead of ActiveRecord objects
+  * `SQL` & `ES|QL` queries resolve their **tabular** response into records _(`find_by_sql` with a String query, `find_by_esql`)_
+  * table (index) names are resolved within the current environment _(`table_name_prefix` / `table_name_suffix`)_
 * Third-party gem support
   * access `elasticsearch-dsl` query builder through `model.search{ ... }`
 * Schema
@@ -254,6 +338,11 @@ buckets = Search.where(name: 'A nice object').aggregate(:total, {sum: {field: :a
 results = Search.where(name: 'A nice object').pit_results
 # > [{ "_id": "abc123", "name": "A nice object", ...
 
+# resolves ONLY the metadata nodes of each hit - the '_source' is not transferred at all.
+# (this is the replacement for a - no longer supported - 'select(:_id)')
+metas = Search.where(name: 'A nice object').meta_only!.results
+# > [{ "_id": "abc123", "_index": "search", "_score": 1.0 }, ...
+
 # returns the total value of the query without querying again (it uses the total value from the response)
 scope = Search.where(name: 'A nice object').limit(5)
 results_count = scope.count
@@ -287,10 +376,7 @@ _(also see @ [github](https://github.com/ruby-smart/elasticsearch_record/blob/ma
 - must
 - should
 - aggregate
-- restrict 
-- hits_only!
-- aggs_only!
-- total_only!
+- select _(raises on metadata fields - see @ [Upgrading to 2.0](#2-select-raises-on-metadata-fields))_
 
 _see simple documentation about these methods @ {ElasticsearchRecord::Relation::QueryMethods rubydoc}_
 
@@ -307,7 +393,7 @@ _(also see @ [github](https://github.com/ruby-smart/elasticsearch_record/blob/ma
 - boxplot
 - stats
 - string_stats
-- matrix_stats
+- matrix_stats _(requires at least two columns)_
 - median_absolute_deviation
 - calculate
 
@@ -315,6 +401,13 @@ _see simple documentation about these methods @ {ElasticsearchRecord::Relation::
 
 _(also see @ [github](https://github.com/ruby-smart/elasticsearch_record/blob/main/lib/elasticsearch_record/relation/calculation_methods.rb) )_
 
+### Available query configuration methods
+
+- hits_only! _(prevents to resolve aggs)_
+- aggs_only! _(prevents to resolve hits / source data)_
+- total_only! _(prevents to resolve aggs, hits / source data)_
+- meta_only! _(resolves the metadata nodes (`_id`, `_score`, ...) of each hit without transferring the `_source`)_
+
 ### Available result methods
 - aggregations
 - buckets
@@ -543,7 +636,7 @@ Access these methods through the model's connection or within any `Migration`.
 **Example migration:**
 
 ```ruby
-class AddTests < ActiveRecord::Migration[7.0]
+class AddTests < ActiveRecord::Migration[7.1]
   def up
     create_table "assignments", if_not_exists: true do |t|
       t.string :key, primary_key: true
@@ -616,17 +709,29 @@ end
 ```
 
 ## environment-related-table-name:
-Using the `_env_table_name`-method will resolve the table (index) name within the current environment,
-even if the environments shares the same cluster ...
+Table (index) names are resolved within the current environment, even if the environments share the
+same cluster ...
 
 This can be provided through the `database.yml` by using the `table_name_prefix/suffix` configuration keys.
-Within the migration the `_env_table_name`-method must be used in combination with the table (index) base name.
+**Every table statement applies them by default**, so a migration only ever names the table (index)
+_base_ name.
 
 **Example:**
 Production uses a index suffix with '-pro', development uses '-dev' - they share the same cluster, but different indexes.
 
-For the **settings** table:
+```yml
+production:
+  elasticsearch:
+    # ...
+    table_name_suffix: '-pro'
+
+development:
+  elasticsearch:
+    # ...
+    table_name_suffix: '-dev'
+```
 
+For the **settings** table / index this results in the following names:
 * settings-pro
 * settings-dev
 
@@ -634,9 +739,10 @@ A single migration can be created to be used within each environment:
 
 ```ruby
 # Example migration
-class AddSettings < ActiveRecord::Migration[7.0]
+class AddSettings < ActiveRecord::Migration[7.1]
   def up
-    create_table _env_table_name("settings"), force: true do |t|
+    # creates 'settings-pro' on production & 'settings-dev' on development
+    create_table "settings", force: true do |t|
       t.mapping :created_at, :date
       t.mapping :key, :integer do |m|
         m.primary_key = true
@@ -653,11 +759,63 @@ class AddSettings < ActiveRecord::Migration[7.0]
   end 
   
   def down
-    drop_table _env_table_name("settings")
+    drop_table "settings"
   end
 end 
 ```
 
+### opting out with `decorate: false`
+
+Provide `decorate: false` to address an index by its **literal** name:
+
+```ruby
+# addresses 'settings-pro' - even from a '-dev' suffixed connection
+drop_table "settings-pro", decorate: false
+```
+
+This is required in two cases:
+
+* the name is **already resolved** _(e.g. `Model.table_name`, or a name read back from `#tables`)_
+* the base name itself **starts with the prefix** or **ends with the suffix** - `_env_table_name`
+  keeps itself idempotent through a `start_with?` / `end_with?` check and cannot tell such a name
+  apart from an already resolved one
+
+The flag only ever applies to table (index) names - `alias`, `mapping`, `setting` & `meta` names are
+never touched. Statements taking **two** names _(`clone_table`, `rename_table`, `reindex_table`,
+`restore_table`, `backup_table`, `create_table copy_from:`)_ resolve both.
+
+The **schema statements** _(`table_exists?`, `table_schema`, `table_mappings`, `table_settings`,
+`columns`, ...)_ are deliberately **not** decorated - ActiveRecord and the schema dumper call them
+with an already resolved index name.
+
+The `_env_table_name`-method itself is still public, so existing migrations keep working - it is now
+redundant, since it resolves the very same name the statement would resolve on its own.
+
+### global kill-switch
+
+The default of a **not explicitly provided** `decorate:` argument is resolved from a global flag:
+
+```ruby
+# e.g. in an initializer
+ElasticsearchRecord.decorate_table_names = false
+```
+
+Setting it to `false` restores the former, opt-in behaviour, where the decoration had to be applied
+by hand through `_env_table_name`. A single statement can still opt in or out on its own, so
+`decorate: true` keeps working while the flag is off:
+
+```ruby
+ElasticsearchRecord.decorate_table_names = false
+
+drop_table "settings"                  # => drops 'settings'
+drop_table "settings", decorate: true  # => drops 'settings-dev'
+drop_table _env_table_name("settings") # => drops 'settings-dev' (the former syntax)
+```
+
+The schema dumper follows the flag: while the decoration is globally disabled it dumps the **full**
+index name with an explicit `decorate: false`, so a dumped schema stays correct even if the flag is
+flipped back on before it is loaded.
+
 ## Docs
 
 [CHANGELOG](docs/CHANGELOG.md)

data/docs/CHANGELOG.md

@@ -1,5 +1,63 @@
 # ElasticsearchRecord - CHANGELOG
 
+## [3.0.0] - 2026-09-08
+* [add] **BREAKING**: requires `activerecord ~> 7.2.0`
+* [add] `Quoting::ClassMethods#quote_column_name` & `#quote_table_name` - identifier quoting is class-level & mandatory now
+* [add] `ElasticsearchRecord::InternalMetadata` - always disabled _(the flag moved from the adapter to the database config)_
+* [add] `patches/active_record/connection_pool_patch` - routes `#migrations_paths`, `#schema_migration` & `#internal_metadata` back to the adapter
+* [add] specs for `ElasticsearchAdapter#translate_exception`
+* [add] specs for `Relation::ValueMethods#limit_value=`
+* [add] specs for `Core#id=`, `#id_was`, `#write_attribute` & `#read_attribute`
+* [add] specs for `TableSettingDefinition`
+* [add] specs for `InternalMetadata#enabled?`
+* [ref] the adapter registers itself through `ActiveRecord::ConnectionAdapters.register` - `ConnectionHandling#elasticsearch_connection` removed
+* [ref] the adapter provides `#internal_metadata` & `#migration_context` again; `#schema_migration` builds from the **pool**
+* [ref] `SchemaMigration#integer_versions` resolves through `pool.with_connection`
+* [ref] `#find_by_sql`, `#find_by_query` & `#find_by_esql` resolve through `with_connection`; `allow_retry:` forwarded down to `#internal_exec_query`
+* [ref] `#_insert_record`, `#_insert_with_auto_increment` & `#cached_find_by_statement` take the connection as first argument
+* [ref] `Arel::Collectors::ElasticsearchQuery#retryable` accessor added _(rails marks idempotent queries as retryable)_
+* [ref] `assert_mutability!` -> `assert_modifiable!` & `ImmutableRelation` -> `UnmodifiableRelation`
+* [ref] `Arel::Nodes::Or` is a nary node now - takes its children as a single `Array`
+* [fix] `Querying::ClassMethods#search` to nest the `Elasticsearch::DSL` block result into the `body` and to only enter the DSL branch **if a block was provided**
+
+## [2.0.0] - 2026-08-10
+* [add] `ElasticsearchRecord.decorate_table_names` _(default: `true`)_ as global kill-switch for the table name decoration - only provides the default for an omitted `decorate:`-argument, `#_env_table_name` stays unaffected
+* [add] `TableStatements#truncate_table` raises an `ArgumentError` for AR-internal indices - the statement runs a `drop` & `create` and would wipe the migration state. `#drop_table` stays unguarded by design _(AR resets both tables through it)_
+* [add] `QueryMethods#select` raises on metadata fields _(`_id`, `_score`, ...)_ - they are always returned anyway
+* [add] `ElasticsearchRecord::Result` now resolves **tabular** responses _(`sql`: columns + rows, `esql`: columns + values)_, so `find_by_sql` _(String)_ & `find_by_esql` instantiate records - rows are zipped against the **response** columns
+* [add] `CalculationMethods#matrix_stats` raises an `ArgumentError` for less than two columns - the metric quantifies the relationship **between** fields
+* [add] `ResultMethods#meta_only!` to resolve the metadata nodes _(`_id`, `_score`, ...)_ of each hit without transferring the `_source`
+* [add] `Query::COLUMNS_NONE` constant for the `'!'` projection marker - replaces the bare literal in `visit_Selects` & `meta_only!`
+* [add] specs for `ElasticsearchRecord::Persistence`, `ModelApi`, `SchemaMigration`, `Querying::ClassMethods`, the `Relation` methods _(Core, Query, Calculation & Result)_, the `Elasticsearch::SchemaStatements`, `TableStatements` & `SchemaDumper`, every class of the `Elasticsearch::Type` namespace _(incl. its `TYPE_MAP` registration)_, `Arel::Collectors::ElasticsearchQuery` and all three `Arel::Visitors::Elasticsearch*` visitors - incl. the 1.8.1 "only ten migrations" and 1.8.2 nested-reset regressions and a `TestIndexWithAutoIncrement` support that builds a model against a real `auto_increment` schema _(destructive calls still run through `TestIndex` and its name guard)_. Behaviours pinned as-is:
+  * `#or` compiles into a **failed** query _(the visitor fails every `Arel::Nodes::Grouping`)_, and AR's blank-arg stripping silently drops `configure(key, nil)` _(only the Hash form removes a key)_
+  * an index **alias** is dumped as a mapping of the elasticsearch 'alias' field type, which makes the `t.alias` branch of the dumper unreachable
+  * opposed nil-handling of metas _(deleted)_ and settings _(kept through `:__force__`)_
+  * a failed `create` has no `FAILED_BODIES` entry and falls back to an empty body; a multi-column `order` keeps only the last sort
+  * `SchemaMigration#count` and `#delete_version` / `#delete_all_versions` cannot be served by elasticsearch
+  * `_update_record` / `_delete_record` always return `0` _(a document-API response carries no `total`)_, and an auto-incremented id is only written as document `_id`, never into the mapped primary-key field
+  * `meta_only!` **spawns** instead of mutating the receiver _(unlike the other bang methods)_ and pins the `COLUMNS_NONE` projection; `pit_results` pins its infinite-loop guard
+* [ref] **BREAKING**: every table statement resolves its table (index) name through `#_env_table_name` **by default** - the `table_name_prefix` / `table_name_suffix` no longer have to be applied by hand, which silently wrote into another environment's index. A new `decorate:`-argument _(default: `true`)_ switches it off per call for already resolved names. Only TABLE names are decorated; schema statements stay undecorated
+* [ref] `SchemaDumper#table` dumps the **base** name instead of a `_env_table_name(...)` call - if that name would not resolve back, the full name is dumped with an explicit `decorate: false`
+* [ref] **BREAKING**: `#open_tables`, `#close_tables`, `#refresh_tables` & `#truncate_tables` no longer subtract the AR-internal indices _(an explicitly named index was silently dropped)_ - plain loops now, forwarding `decorate:` to their singular statement and returning an `Array` for every provided name
+* [ref] `TableStatements` drops the stale `:rename_table` entry from `define_unsupported_method` - the real implementation overwrote it anyway
+* [ref] `#restore_table` replaces its `open`-argument with `unblock:` _(default: true)_ - a restore clones and inherits the 'write'-block, so the table was open but **read-only**. `ModelApi#restore!` follows along
+* [ref] `ResultMethods#pit_results` resolves through `ElasticsearchRecord::Result` and respects the current projection _(`ids_only` removed in favour of `meta_only!`)_
+* [ref] `TestIndex` spec support to optionally create/drop a second index _(still guarded by the `ALLOWED` name check)_
+* [fix] `#rename_table` to resolve both names **itself** - the `clear_data_source_cache!` and `cluster_health` calls in between were left with the undecorated name
+* [fix] `#backup_table` to build the auto-generated target from the **already resolved** name _(the suffix landed behind the `-snapshot-` part)_
+* [fix] `#_env_table_name` to cast prefix & suffix - an empty `table_name_prefix:` yml entry resolves to `nil` and raised a `TypeError`
+* [fix] `Result#cast_values` to resolve values from the `_source` node, metadata fields from the document level
+* [fix] `visit_Selects` to no longer provide metadata fields to the `_source`-filter _(never matched)_ - projects `_source: false` if only metadata is selected
+* [fix] `Querying::ClassMethods#esql` & `#msearch` to dispatch through the public `exec_query` _(rails 7.1 made `internal_exec_query` private)_ - the `async:`-argument was dropped along with it
+* [fix] `Querying::ClassMethods#find_by_sql` to reference the provided `sql` for `String` queries _(undefined `query_or_sql` raised a `NameError`)_
+* [fix] `SchemaStatements#max_result_window` to resolve the **flat** setting key and cast it to an `Integer` _(always fell back to 10000 and broke the batch_size guards)_
+* [fix] `SchemaStatements#primary_keys` to always return an `Array` _(the `_meta` branch returned a raw String)_
+* [fix] `CalculationMethods#count` to apply the SQL `LIMIT n OFFSET m` semantic on the resolved total - `terminate_after` alone acts **per shard** and never fires on a count query. `#size` on an unloaded relation was affected as well
+* [fix] `UpdateTableDefinition#change_mapping_attributes` to resolve the current mapping type with a **String** key _(fell back to `:object` / `:nested`, so elasticsearch rejected every mapping parameter)_
+* [fix] `#restore_table` to no longer touch the backup after a `drop_backup: true` _(it no longer exists at that point)_
+* [fix] `_insert_with_auto_increment` to write the **plain, integer** id into `_meta.auto_increment` - the block returns an Array of the `returning` values, which was stored as-is and raised on the NEXT insert. Now unwraps Array / Hash / plain and casts to `Integer`
+* [fix] `ResultMethods#pit_delete` to no longer `select('_id')` _(rejected by the new metadata guard)_ - resolves the ids through `meta_only!`
+
 ## [1.8.2] - 2024-11-26
 * [fix] `ElasticsearchRecord::Relation::QueryMethods#build_query_clause` to raise an exception on `nil` assignments
 * [fix] `Arel::Visitors::ElasticsearchBase#compile` to always reset temporary assignments _(causes missing assignments after a query-build-exception)_
@@ -18,6 +76,14 @@
 * [add] new repository branch `rails-7-1-stable` to support different rails version
 * [ref] gemspec to lock on rails 7.1
 
+## [1.7.5] - 2024-11-26 _(no gem release)_
+* [ref] `ElasticsearchRecord::Relation::QueryMethods#build_query_clause` to raise an exception instead of building an empty `QueryClause`
+
+## [1.7.4] - 2024-11-25 _(no gem release)_
+* [fix] `Arel::Visitors::ElasticsearchBase#compile` to always reset temporary assignments _(causes missing assignments after a query-build-exception)_
+* [fix] `Arel::Nodes::SelectAgg` to not merge nil-values
+* [fix] `ElasticsearchRecord::Relation::QueryMethods#build_query_clause` to prevent nil-Array assignment _(e.g. `[nil]` causes q query exception)_
+
 ## [1.7.3] - 2024-05-07 _(no gem release)_
 * [add] new elasticsearch mapping types _(percolator, geo, vector, texts, ...)_
 * [ref] `ElasticsearchRecord::Relation#limit` to detect `Float::INFINITY` to also set the **max_result_window**

data/elasticsearch_record.gemspec

@@ -14,7 +14,7 @@ DESC
 
   spec.homepage              = "https://github.com/ruby-smart/elasticsearch_record"
   spec.license               = "MIT"
-  spec.required_ruby_version = ">= 2.7.0"
+  spec.required_ruby_version = ">= 3.1.0"
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
   spec.metadata["homepage_uri"]      = spec.homepage
@@ -32,10 +32,10 @@ DESC
 
   spec.require_paths = ["lib"]
 
-  spec.add_dependency 'activerecord', '~> 7.1.0'
+  spec.add_dependency 'activerecord', '~> 7.2.0'
   spec.add_dependency 'elasticsearch', '>= 7.17'
 
-  #spec.add_development_dependency 'coveralls_reborn', '~> 0.25'
+  spec.add_development_dependency 'coveralls_reborn', '~> 0.25'
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'rake', "~> 13.0"
   spec.add_development_dependency 'yard', '~> 0.9'

data/lib/active_record/connection_adapters/elasticsearch/database_statements.rb

@@ -131,14 +131,30 @@ module ActiveRecord
 
           private
 
+          # gets called for all queries - a +ElasticsearchRecord::Query+ must be provided.
+          # @param [ElasticsearchRecord::Query] query
+          # @param [String (frozen),nil] name
+          # @param [Array] binds - not supported on the top-level and therefore ignored!
+          # @param [Boolean] prepare - used by the default AbstractAdapter - but not supported and therefore never ignored!
+          # @param [Boolean] async
+          # @param [Boolean] allow_retry
+          # @return [ElasticsearchRecord::Result]
+          def internal_exec_query(query, name = "QUERY", binds = [], prepare: false, async: false, allow_retry: false)
+            build_result(
+              internal_execute(query, name, async: async, allow_retry: allow_retry),
+              columns: query.columns
+            )
+          end
+
           # Executes the query object in the context of this connection and returns the raw result
           # from the connection adapter.
           # @param [ElasticsearchRecord::Query] query
           # @param [String (frozen),nil] name
-          # @param [Boolean] async (default: false)
+          # @param [Boolean] async (default: false) - NOT supported!
           # @param [Boolean] allow_retry (default: false)
+          # @param [Boolean] materialize_transactions (default: false) - NOT supported!
           # @return [ElasticsearchRecord::Result]
-          def internal_execute(query, name = nil, async: false, allow_retry: false, materialize_transactions: nil)
+          def internal_execute(query, name = nil, async: false, allow_retry: false, materialize_transactions: false)
             # validate the query
             raise ActiveRecord::StatementInvalid, 'Unable to execute! Provided query is not a "ElasticsearchRecord::Query".' unless query.is_a?(ElasticsearchRecord::Query)
             raise ActiveRecord::StatementInvalid, 'Unable to execute! Provided query is invalid.' unless query.valid?
@@ -146,21 +162,7 @@ module ActiveRecord
             # checks for write query - raises an exception if connection is locked to readonly ...
             check_if_write_query(query)
 
-            api(*query.gate, query.query_arguments, name, async: async)
-          end
-
-          # gets called for all queries - a +ElasticsearchRecord::Query+ must be provided.
-          # @param [ElasticsearchRecord::Query] query
-          # @param [String (frozen),nil] name
-          # @param [Array] binds - not supported on the top-level and therefore ignored!
-          # @param [Boolean] prepare - used by the default AbstractAdapter - but not supported and therefore never ignored!
-          # @param [Boolean] async
-          # @return [ElasticsearchRecord::Result]
-          def internal_exec_query(query, name = "QUERY", binds = [], prepare: false, async: false)
-            build_result(
-              internal_execute(query, name, async: async),
-              columns: query.columns
-            )
+            api(query.gate, query.query_arguments, name, async: async, allow_retry: allow_retry, materialize_transactions: materialize_transactions)
           end
         end
       end

data/lib/active_record/connection_adapters/elasticsearch/quoting.rb

@@ -4,6 +4,22 @@ module ActiveRecord
   module ConnectionAdapters
     module Elasticsearch
       module Quoting # :nodoc:
+        extend ActiveSupport::Concern
+
+        module ClassMethods # :nodoc:
+          # since rails 7.2 identifier quoting is class-level & mandatory (the abstract
+          # implementation raises a +NotImplementedError+). Elasticsearch fields & indices are
+          # plain JSON keys - so they pass through unquoted.
+          def quote_column_name(column_name)
+            column_name.to_s
+          end
+
+          # Quotes the table (index) name. Defaults to column name quoting.
+          def quote_table_name(table_name)
+            quote_column_name(table_name)
+          end
+        end
+
         def quoted_true
           'true'
         end

data/lib/active_record/connection_adapters/elasticsearch/schema_definitions/create_table_definition.rb

@@ -14,6 +14,12 @@ module ActiveRecord
           @aliases  = HashWithIndifferentAccess.new
           @metas    = HashWithIndifferentAccess.new
 
+          # HINT: Currently there is only one attribute, that cannot be assigned to any of the top hash kind, and also not opts:
+          # * dynamic
+          # This attribute must be assigned below the *mappings* node but as sibling to *properties*.
+          # This can only be done to create a special kind of options (@flags ???) and assign & fetch them within the required arel.
+          # Since this only setting can also be assigned to each individual mapping, there is currently no need to build this ...
+
           transform_settings!(settings) if settings.present?
           transform_mappings!(mappings) if mappings.present?
           transform_aliases!(aliases) if aliases.present?

data/lib/active_record/connection_adapters/elasticsearch/schema_definitions/table_setting_definition.rb

@@ -10,7 +10,7 @@ module ActiveRecord
         include ActiveModel::Validations
 
         # exclude settings, that are provided through the API but are not part of the index-settings API
-        IGNORE_NAMES = ['provided_name', 'creation_date', 'uuid', 'version','routing.allocation.initial_recovery','resize'].freeze
+        IGNORE_NAMES = ['provided_name', 'creation_date', 'uuid', 'version', 'routing.allocation.initial_recovery', 'resize'].freeze
 
         # available setting names
         # - see @ https://www.elastic.co/guide/en/elasticsearch/reference/current/index-modules.html#index-modules-settings
@@ -19,13 +19,12 @@ module ActiveRecord
         FINAL_NAMES = ['number_of_shards', 'routing_partition_size', 'soft_deletes.enabled'].freeze
 
         # static names can only be set during index creation or closed
-        STATIC_NAMES = ['number_of_routing_shards', 'codec',
+        STATIC_NAMES = ['number_of_routing_shards', 'codec', 'mode',
                         'soft_deletes.retention_lease.period',
                         'load_fixed_bitset_filters_eagerly', 'shard.check_on_startup',
 
                         # modules
-                        'analysis', 'routing', 'unassigned', 'merge', 'similarity', 'search', 'store', 'translog',
-                        'indexing_pressure'].freeze
+                        'analysis', 'routing', 'unassigned', 'merge', 'similarity', 'search', 'store', 'indexing_pressure'].freeze
 
         # dynamic names can always be changed
         DYNAMIC_NAMES = ['number_of_replicas', 'auto_expand_replicas', "search.idle.after", 'refresh_interval',
@@ -34,7 +33,10 @@ module ActiveRecord
                          'max_refresh_listeners', 'analyze.max_token_count', 'highlight.max_analyzed_offset',
                          'max_terms_count', 'max_regex_length', 'query.default_field', 'routing.allocation.enable',
                          'routing.rebalance.enable', 'gc_deletes', 'default_pipeline', 'final_pipeline',
-                         'hidden', 'blocks'].freeze
+                         'hidden', 'blocks',
+
+                         # modules
+                         'translog'].freeze
 
         VALID_NAMES = (FINAL_NAMES + STATIC_NAMES + DYNAMIC_NAMES).freeze
 

data/lib/active_record/connection_adapters/elasticsearch/schema_definitions/update_table_definition.rb

@@ -66,7 +66,9 @@ module ActiveRecord
           raise ArgumentError, "you cannot change an unknown mapping '#{name}'" if current_mapping.blank?
 
           # build new mapping
-          mapping = new_mapping_definition(name, current_mapping[:type], **options, &block)
+          # IMPORTANT: the received mapping is a String-keyed Hash - a symbol access would resolve
+          # nil here, which +TableMappingDefinition+ then falls back to :object / :nested
+          mapping = new_mapping_definition(name, current_mapping['type'], **options, &block)
           define! ChangeMappingDefinition, mapping
 
           # check if the mapping is assigned as new primary_key