elasticsearch_record 1.8.2 → 3.0.0

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

@@ -45,6 +45,25 @@ module ActiveRecord
           false
         end
 
+        # returns true if the BASE name may be dumped, which keeps the dump loadable in another
+        # environment (with its own prefix / suffix): every table statement decorates its name on
+        # its own, so the base name may only be dumped if that decoration lands on exactly this
+        # index again. Otherwise the FULL name is dumped with a +decorate: false+.
+        #
+        # see @ ActiveRecord::ConnectionAdapters::Elasticsearch::TableStatements#_env_table_name
+        def _dumps_base_name?(table, base_name)
+          # without a prefix & suffix nothing is ever decorated - the plain name IS the index
+          return true unless _has_env_table_names?
+
+          # a globally disabled decoration would leave the base name untouched while loading
+          return false unless ElasticsearchRecord.decorate_table_names
+
+          # the base name must resolve BACK to the real index. It does not if the base name itself
+          # starts with the prefix (or ends with the suffix), and not if the dumper was built with a
+          # prefix / suffix that differs from the one of the connection.
+          @connection._env_table_name(base_name) == table
+        end
+
         def table(table, stream, nested_blocks: false, **)
           begin
             self.table_name = table
@@ -57,10 +76,12 @@ module ActiveRecord
 
             tbl.print "  create_table"
 
-            if _has_env_table_names?
-              tbl.print " _env_table_name(#{remove_prefix_and_suffix(table).inspect})"
+            base_name = remove_prefix_and_suffix(table)
+
+            if _dumps_base_name?(table, base_name)
+              tbl.print " #{base_name.inspect}"
             else
-              tbl.print " #{remove_prefix_and_suffix(table).inspect}"
+              tbl.print " #{table.inspect}, decorate: false"
             end
 
             tbl.print ", force: true do |t|"

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

@@ -92,13 +92,13 @@ module ActiveRecord
                                     :dump_schema_information
 
           def assume_migrated_upto_version(version)
-            version  = version.to_i
+            version = version.to_i
             migrated = migration_context.get_all_versions
             versions = migration_context.migrations.map(&:version)
 
             unless migrated.include?(version)
-              # use a ActiveRecord syntax to create a new version
-              schema_migration.create(version: version)
+              # use Arel syntax to create a new version
+              schema_migration.create_version(version)
             end
 
             inserting = (versions - migrated).select { |v| v < version }
@@ -107,8 +107,8 @@ module ActiveRecord
                 raise "Duplicate migration #{duplicate}. Please renumber your migrations to resolve the conflict."
               end
 
-              # use a ActiveRecord syntax to create new versions
-              inserting.each { |iversion| schema_migration.create(version: iversion) }
+              # use Arel syntax to create new versions
+              inserting.each { |iversion| schema_migration.create_version(iversion) }
             end
 
             true
@@ -119,7 +119,7 @@ module ActiveRecord
           # @see ActiveRecord::ConnectionAdapters::SchemaStatements#data_sources
           # @return [Array<String>]
           def data_sources
-            api(:indices, :get, { index: :_all, expand_wildcards: [:open, :closed] }, 'SCHEMA').keys
+            api('indices.get', { index: :_all, expand_wildcards: [:open, :closed] }, 'SCHEMA').keys
           end
 
           # Returns an array of table names defined in the database.
@@ -134,7 +134,7 @@ module ActiveRecord
           # @param [String] table_name
           # @return [Hash]
           def table_mappings(table_name)
-            api(:indices, :get_mapping, { index: table_name, expand_wildcards: [:open, :closed] }, 'SCHEMA').dig(table_name, 'mappings')
+            api('indices.get_mapping', { index: table_name, expand_wildcards: [:open, :closed] }, 'SCHEMA').dig(table_name, 'mappings')
           end
 
           # returns a hash of all meta data by provided table_name (index).
@@ -150,21 +150,21 @@ module ActiveRecord
           # @param [Boolean] flat_settings (default: true)
           # @return [Hash]
           def table_settings(table_name, flat_settings = true)
-            api(:indices, :get_settings, { index: table_name, expand_wildcards: [:open, :closed], flat_settings: flat_settings }, 'SCHEMA').dig(table_name, 'settings')
+            api('indices.get_settings', { index: table_name, expand_wildcards: [:open, :closed], flat_settings: flat_settings }, 'SCHEMA').dig(table_name, 'settings')
           end
 
           # returns a hash of all aliases by provided table_name (index).
           # @param [String] table_name
           # @return [Hash]
           def table_aliases(table_name)
-            api(:indices, :get_alias, { index: table_name, expand_wildcards: [:open, :closed] }, 'SCHEMA').dig(table_name, 'aliases')
+            api('indices.get_alias', { index: table_name, expand_wildcards: [:open, :closed] }, 'SCHEMA').dig(table_name, 'aliases')
           end
 
           # returns information about number of primaries and replicas, document counts, disk size, ... by provided table_name (index).
           # @param [String] table_name
           # @return [Hash]
           def table_state(table_name)
-            response = api(:cat, :indices, { index: table_name, expand_wildcards: [:open, :closed] }, 'SCHEMA')
+            response = api('cat.indices', { index: table_name, expand_wildcards: [:open, :closed] }, 'SCHEMA')
 
             [:health, :status, :name, :uuid, :pri, :rep, :docs_count, :docs_deleted, :store_size, :pri_store_size].zip(
               response.body.split(' ')
@@ -178,15 +178,15 @@ module ActiveRecord
           # @return [Hash]
           def table_schema(table_name, features = [:aliases, :mappings, :settings])
             if cluster_info[:version] >= '8.5.0'
-              response = api(:indices, :get, { index: table_name, expand_wildcards: [:open, :closed], features: features, flat_settings: true }, 'SCHEMA')
+              response = api('indices.get', { index: table_name, expand_wildcards: [:open, :closed], features: features, flat_settings: true }, 'SCHEMA')
             else
-              response = api(:indices, :get, { index: table_name, expand_wildcards: [:open, :closed], flat_settings: true }, 'SCHEMA')
+              response = api('indices.get', { index: table_name, expand_wildcards: [:open, :closed], flat_settings: true }, 'SCHEMA')
             end
 
             {
               settings: response.dig(table_name, 'settings'),
               mappings: response.dig(table_name, 'mappings'),
-              aliases:  response.dig(table_name, 'aliases')
+              aliases: response.dig(table_name, 'aliases')
             }
           end
 
@@ -204,8 +204,8 @@ module ActiveRecord
             # raise(ActiveRecord::StatementInvalid, "Could not find valid mappings for '#{table_name}'") if mappings.blank? || mappings['properties'].blank?
 
             # since the received mappings do not have the "primary" +_id+-column we manually need to add this here
-            # The BASE_STRUCTURE will also include some meta keys like '_score', '_type', ...
-            ActiveRecord::ConnectionAdapters::ElasticsearchAdapter::BASE_STRUCTURE + mappings['properties'].map { |key, prop|
+            # The METADATA_FIELDS will also include some meta keys like '_score', '_type', ...
+            ActiveRecord::ConnectionAdapters::ElasticsearchAdapter::METADATA_FIELDS + mappings['properties'].map { |key, prop|
               # resolve (nested) fields and properties
               fields, properties = resolve_fields_and_properties(key, prop, true)
 
@@ -228,11 +228,11 @@ module ActiveRecord
               field["name"],
               field["null_value"],
               fetch_type_metadata(field["type"]),
-              meta:       field['meta'],
-              virtual:    field['virtual'],
-              fields:     field['fields'],
+              meta: field['meta'],
+              virtual: field['virtual'],
+              fields: field['fields'],
               properties: field['properties'],
-              enabled:    field['enabled']
+              enabled: field['enabled']
             )
           end
 
@@ -250,13 +250,16 @@ module ActiveRecord
           # The only thing that uniquely identifies a document is the index together with the +_id+.
           # To support this concept we simulate this through the +_meta+ field (from the index).
           #
-          # As a alternative, the primary_key can also be provided through the mappings +meta+ field.
-          #
-          # see @ https://www.elastic.co/guide/en/elasticsearch/reference/8.5/mapping-meta-field.html
+          # As an alternative, the primary_key can also be provided through the mappings +meta+ field.
+          # - see @ https://www.elastic.co/guide/en/elasticsearch/reference/8.5/mapping-meta-field.html
+
           # @see ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter#primary_keys
           # @param [String] table_name
+          # @return [Array<String>]
           def primary_keys(table_name)
-            table_metas(table_name).dig('primary_key').presence || column_definitions(table_name).
+            # IMPORTANT: the +_meta+ node stores the primary_key as a plain String - it must be
+            # wrapped, so every branch of this method returns an Array (as the API demands).
+            Array.wrap(table_metas(table_name).dig('primary_key')).presence || column_definitions(table_name).
               select { |f| f['meta'] && f['meta']['primary_key'] == 'true' }.
               # only take the last found primary key (if no custom primary_key was provided this will return +_id+ )
               map { |f| f["name"] }[-1..-1]
@@ -270,7 +273,7 @@ module ActiveRecord
           # @return [Boolean]
           def data_source_exists?(name)
             # response returns boolean
-            api(:indices, :exists?, { index: name, expand_wildcards: [:open, :closed] }, 'SCHEMA')
+            api('indices.exists?', { index: name, expand_wildcards: [:open, :closed] }, 'SCHEMA')
           end
 
           # Checks to see if the table +table_name+ exists on the database.
@@ -358,7 +361,9 @@ module ActiveRecord
           # The query will raise an ActiveRecord::StatementInvalid if the requested limit is above this value.
           # @return [Integer]
           def max_result_window(table_name)
-            table_settings(table_name).dig('index', 'max_result_window').presence || 10000
+            # IMPORTANT: the settings API returns every value as a String - without the cast the
+            # callers would compare a String against their (Integer) batch sizes.
+            table_settings(table_name).dig('index.max_result_window').presence&.to_i || 10_000
           end
 
           # returns true if the cluster option 'id_field_data' is enabled or not configured.
@@ -388,13 +393,13 @@ module ActiveRecord
           # @return [Hash{Symbol->Unknown}]
           def cluster_info
             @cluster_info ||= begin
-                                response = api(:core, :info, {}, 'CLUSTER INFO')
+                                response = api(:info, {}, 'CLUSTER INFO')
 
                                 {
-                                  name:           response.dig('name'),
-                                  cluster_name:   response.dig('cluster_name'),
-                                  cluster_uuid:   response.dig('cluster_uuid'),
-                                  version:        Gem::Version.new(response.dig('version', 'number')),
+                                  name: response.dig('name'),
+                                  cluster_name: response.dig('cluster_name'),
+                                  cluster_uuid: response.dig('cluster_uuid'),
+                                  version: Gem::Version.new(response.dig('version', 'number')),
                                   lucene_version: response.dig('version', 'lucene_version')
                                 }
                               end
@@ -403,14 +408,14 @@ module ActiveRecord
           # returns a hash of current set, none-default settings in flat
           # @return [Hash]
           def cluster_settings
-            settings = api(:cluster, :get_settings, { flat_settings: true }, 'CLUSTER SETTINGS')
+            settings = api('cluster.get_settings', { flat_settings: true }, 'CLUSTER SETTINGS')
             settings['persistent'].merge(settings['transient'])
           end
 
           # returns the cluster health
           # @return [Hash]
           def cluster_health(**options)
-            api(:cluster, :health, options, 'CLUSTER HEALTH').to_h
+            api('cluster.health', options, 'CLUSTER HEALTH').to_h
           end
 
           # transforms provided schema-type to a sql-type
@@ -469,8 +474,8 @@ module ActiveRecord
             if prop['properties'].present?
               prop['properties'].each do |nested_key, nested_prop|
                 nested_fields, nested_properties = resolve_fields_and_properties("#{key}.#{nested_key}", nested_prop)
-                fields                           |= nested_fields
-                properties                       |= nested_properties
+                fields |= nested_fields
+                properties |= nested_properties
               end
             elsif !root # don't add the root property as sub-property
               properties << { 'name' => key, 'type' => prop['type'] }