elasticsearch_record 1.0.2 → 1.1.0

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'active_model/validations'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Elasticsearch
+      class TableAliasDefinition
+        include AttributeMethods
+        include ActiveModel::Validations
+
+        # available alias properties
+        # - see @ https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-create-index.html#indices-create-api-request-body
+        ATTRIBUTES = [:filter, :index_routing, :is_hidden, :is_write_index, :routing, :search_routing].freeze
+        build_attribute_methods! *ATTRIBUTES
+
+        # attributes
+        attr_accessor :name
+        attr_accessor :attributes
+
+        # validations
+        validates_presence_of :name
+        validates_inclusion_of :__attributes_keys, in: ATTRIBUTES, allow_blank: true
+
+        def initialize(name, attributes)
+          self.name       = name.to_sym
+          self.attributes = attributes.symbolize_keys
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+# required to load related definitions
+# - ActiveRecord::ConnectionAdapters::ReferenceDefinition
+require 'active_record/connection_adapters/abstract/schema_definitions'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Elasticsearch
+      class TableDefinition
+        include ColumnMethods
+
+        delegate :execute, :schema_creation, :column_exists?, :mapping_exists?, :setting_exists?, :alias_exists?, :close_table, :open_table, :table_mappings, to: :conn
+
+        attr_reader :conn
+        attr_reader :name
+        attr_reader :opts
+
+        def initialize(conn, name, **opts)
+          @conn = conn
+          @name = name
+          @opts = opts
+          @failed = false
+        end
+
+        # yields provided block with self to change the table and collect table information
+        # returns self, to chain this method
+        def assign
+          # if before assign fails, we don't want to continue yielding!
+          _before_assign
+
+          begin
+            yield self
+          rescue => e
+            @failed = false
+            raise e
+          ensure
+            _after_assign
+          end
+        end
+
+        def exec!
+          # if before exec fails, we don't want to continue with execution!
+          _before_exec
+
+          begin
+            _exec
+          rescue => e
+            @failed = false
+            raise e
+          ensure
+            _after_exec
+          end
+        end
+
+        def failed?
+          @failed
+        end
+
+        private
+
+        def _before_assign
+          true
+        end
+
+        def _after_assign
+          true
+        end
+
+        def _before_exec
+          true
+        end
+
+        def _after_exec
+          true
+        end
+
+        def _exec
+          raise ArgumentError, "you cannot execute a TableDefinition directly - use 'CreateTableDefinition' or 'UpdateTableDefinition' instead!"
+        end
+
+        def new_mapping_definition(name, type, strict: true, **attributes, &block)
+          mapping = TableMappingDefinition.new(name, type, attributes)
+          block.call(mapping) if block_given?
+
+          raise ArgumentError, "you cannot define an invalid mapping '#{name}' (#{mapping.error_messages})!" if strict?(strict) && !mapping.valid?
+
+          mapping
+        end
+
+        alias :new_column_definition :new_mapping_definition
+
+        def new_alias_definition(name, strict: true, **attributes, &block)
+          # create new alias
+          tbl_alias = TableAliasDefinition.new(name, attributes)
+          block.call(tbl_alias) if block_given?
+
+          raise ArgumentError, "you cannot define an invalid alias '#{tbl_alias}' (#{tbl_alias.error_messages})!" if strict?(strict) && !tbl_alias.valid?
+
+          tbl_alias
+        end
+
+        def new_setting_definition(name, value, strict: true, **, &block)
+          # create new setting
+          setting = TableSettingDefinition.new(name, value).with_state(state)
+          block.call(setting) if block_given?
+
+          raise ArgumentError, "you cannot define an invalid setting '#{name}' (#{setting.error_messages})!" if strict?(strict) && !setting.valid?
+
+          setting
+        end
+
+        # returns the state of the current table.
+        def state
+          @state ||= conn.table_state(name) rescue { status: 'missing', name: name }
+        end
+
+        def clear_state!
+          @state = nil
+        end
+
+        def force?(fallback = false)
+          opts.fetch(:force, fallback)
+        end
+
+        def strict?(strict = nil)
+          opts.fetch(:strict, true) && strict != false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'active_model/validations'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Elasticsearch
+      class TableMappingDefinition
+        include AttributeMethods
+        include ActiveModel::Validations
+
+        # available mapping properties
+        # - see @ https://www.elastic.co/guide/en/elasticsearch/reference/current/mapping-params.html
+        ATTRIBUTES = [:analyzer, :coerce, :copy_to, :doc_values, :dynamic, :eager_global_ordinals, :enabled,
+                      :fielddata, :fields, :format, :ignore_above, :ignore_malformed, :index_options, :index_phrases,
+                      :index_prefixes, :index, :meta, :normalizer, :norms, :null_value, :position_increment_gap,
+                      :properties, :search_analyzer, :similarity, :subobjects, :store, :term_vector].freeze
+
+        build_attribute_methods! *ATTRIBUTES
+
+        # attributes
+        attr_accessor :name
+        attr_accessor :type
+        attr_accessor :attributes
+
+        # validations
+        validates_presence_of :name
+        validates_presence_of :type
+        validates_inclusion_of :__attributes_keys, in: ATTRIBUTES, allow_blank: true
+
+        # disable validation for meta attribute - maybe future updates of Elasticsearch have other restrictions.
+        # To not be hooked on those possible changes we
+        #validate :_validate_meta
+
+        # sets the default value (alias for null_value)
+        alias_method :default=, :null_value=
+        alias_method :default, :null_value
+
+        ####################
+        # INSTANCE METHODS #
+        ####################
+
+        def initialize(name, type, attributes)
+          @name       = name.to_sym
+          @attributes = attributes.symbolize_keys
+
+          @type = _resolve_type(type)
+        end
+
+        # comment is handled as nested key from 'meta' attribute
+        def comment
+          __get_nested(:meta, :comment)
+        end
+
+        def comment=(value)
+          # important: meta-values can only be strings!
+          __set_nested(:meta, :comment, value.to_s)
+        end
+
+        def primary_key
+          __get_nested(:meta, :primary_key) == 'true'
+        end
+
+        alias_method :primary_key?, :primary_key
+
+        # defines this mapping as a primary key
+        def primary_key=(value)
+          # important: meta-values can only be strings!
+          __set_nested(:meta, :primary_key, value ? 'true' : nil)
+        end
+
+        def meta=(value)
+          if value.nil?
+            __remove_attribute(:meta)
+          else
+            __set_attribute(:meta, value.compact)
+          end
+        end
+
+        private
+
+        # resolves the provided type.
+        # prevents to set a nil type (sets +:object+ or +:nested+ - depends on existing properties)
+        # @return [Symbol, nil]
+        def _resolve_type(type)
+          return type.to_sym if type.present?
+
+          # fallback for possible empty type
+          (properties.present? ? :object : :nested)
+        end
+
+        # validates metadata restrictions
+        def _validate_meta
+          return true if meta.nil?
+
+          return invalid!("'meta' must be a hash", :attributes) unless meta.is_a?(Hash)
+          return invalid!("'meta' enforces at most 5 entries", :attributes) if meta.length > 5
+          return invalid!("'meta' has a key with more then 20 chars", :attributes) if meta.keys.any? { |key| key.length > 20 }
+          return invalid!("'meta' is not supported on object or nested types", :attributes) if [:object, :nested].include?(type)
+
+          # allow only strings
+          vkey = meta.keys.detect { |key| !meta[key].is_a?(String) }
+          return invalid!("'meta' has a key '#{vkey}' with a none string value", :attributes) if vkey.present?
+
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require 'active_model/validations'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Elasticsearch
+      class TableSettingDefinition
+        include AttributeMethods
+        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'].freeze
+
+        # available setting names
+        # - see @ https://www.elastic.co/guide/en/elasticsearch/reference/current/index-modules.html#index-modules-settings
+
+        # final names can only be set during index creation
+        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',
+                        '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
+
+        # dynamic names can always be changed
+        DYNAMIC_NAMES = ['number_of_replicas', 'auto_expand_replicas', "search.idle.after", 'refresh_interval',
+                         'max_result_window', 'max_inner_result_window', 'max_rescore_window',
+                         'max_docvalue_fields_search', 'max_script_fields', 'max_ngram_diff', 'max_shingle_diff',
+                         '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'].freeze
+
+        VALID_NAMES = (FINAL_NAMES + STATIC_NAMES + DYNAMIC_NAMES).freeze
+
+        # attributes
+        attr_accessor :name
+        attr_accessor :value
+
+        # validations
+        validates_presence_of :name
+        validate :_validate_name
+        validate :_validate_final_name
+        validate :_validate_static_name
+
+        def self.match_ignore_names?(name)
+          IGNORE_NAMES.any? { |invalid| name.match?(invalid) }
+        end
+
+        def self.match_valid_names?(name)
+          VALID_NAMES.any? { |invalid| name.match?(invalid) }
+        end
+
+        def self.match_final_names?(name)
+          FINAL_NAMES.any? { |invalid| name.match?(invalid) }
+        end
+
+        def self.match_dynamic_names?(name)
+          DYNAMIC_NAMES.any? { |invalid| name.match?(invalid) }
+        end
+
+        def self.match_static_names?(name)
+          STATIC_NAMES.any? { |invalid| name.match?(invalid) }
+        end
+
+        def initialize(name, value)
+          @name  = name.to_s
+          @value = value
+        end
+
+        def final?
+          @final = flat_names.all? { |flat_name| self.class.match_final_names?(flat_name) } if @final.nil?
+          @final
+        end
+
+        def static?
+          !dynamic?
+        end
+
+        def dynamic?
+          @dynamic = flat_names.all? { |flat_name| self.class.match_dynamic_names?(flat_name) } if @dynamic.nil?
+          @dynamic
+        end
+
+        # returns a array of flat names
+        def flat_names
+          @flat_names ||= _generate_flat_names.uniq
+        end
+
+        private
+
+        def _validate_name
+          invalid_name = flat_names.detect { |flat_name| !self.class.match_valid_names?(flat_name) }
+
+          invalid!("is invalid!", :name) if invalid_name.present?
+        end
+
+        def _validate_static_name
+          return true if dynamic?
+          return true if ['missing', 'close'].include?(_table_status)
+
+          invalid!("is static - this setting can only be changed on a closed index!", :name)
+        end
+
+        def _validate_final_name
+          return true unless final?
+          return true if _table_status == 'missing'
+
+          invalid!("is final - this setting can only be set at index creation time!", :name)
+        end
+
+        def _generate_flat_names(parent = name, current = value)
+          ret = []
+          if current.is_a?(Hash)
+            current.each do |k, v|
+              ret += _generate_flat_names("#{parent}.#{k}", v)
+            end
+          else
+            ret << parent.to_s
+          end
+
+          ret
+        end
+
+        def _table_status
+          return 'missing' unless state?
+          state[:status]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'active_record/connection_adapters/abstract/schema_definitions'
+require 'active_record/connection_adapters/elasticsearch/schema_definitions/table_definition'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Elasticsearch
+      class UpdateTableDefinition < TableDefinition
+
+        attr_reader :definitions
+
+        # defines which definitions can be executed composite
+        COMPOSITE_DEFINITIONS = [
+          AddMappingDefinition,
+          ChangeMappingDefinition,
+
+          AddSettingDefinition,
+          DeleteAliasDefinition
+        ].freeze
+
+        def add_mapping(name, type, if_not_exists: false, **options, &block)
+          return if if_not_exists && mapping_exists?(self.name, name, type)
+
+          define! AddMappingDefinition, new_mapping_definition(name, type, **options, &block)
+        end
+
+        alias :add_column :add_mapping
+        alias :mapping :add_mapping
+        alias :column :add_mapping
+
+        def change_mapping(name, type, if_exists: false, **options, &block)
+          return if if_exists && !mapping_exists?(self.name, name, type)
+
+          define! ChangeMappingDefinition, new_mapping_definition(name, type, **options, &block)
+        end
+
+        alias :change_column :change_mapping
+        alias :change :change_mapping
+
+        def change_mapping_meta(name, **options)
+          mapping = table_mappings(self.name).dig('properties', name.to_s)
+          raise ArgumentError, "you cannot change the 'meta' parameter for an unknown mapping '#{name}'" if mapping.blank?
+
+          # resolve existing meta & merge with new
+          meta = (mapping['meta'] || {}).merge(options)
+
+          define! ChangeMappingDefinition, new_mapping_definition(name, mapping['type'], meta: meta)
+        end
+
+        def change_mapping_attributes(name, **options, &block)
+          mapping = table_mappings(self.name).dig('properties', name.to_s)
+          raise ArgumentError, "you cannot change parameters for an unknown mapping '#{name}'" if mapping.blank?
+
+          options = mapping.with_indifferent_access.except(:type).merge(options) if options.present?
+
+          define! ChangeMappingDefinition, new_mapping_definition(name, mapping['type'], **options, &block)
+        end
+        alias :change_mapping_attribute :change_mapping_attributes
+
+        def add_setting(name, value, if_not_exists: false, **options, &block)
+          return if if_not_exists && setting_exists?(self.name, name)
+
+          define! AddSettingDefinition, new_setting_definition(name, value, **options, &block)
+        end
+
+        def change_setting(name, value, if_exists: false, **options, &block)
+          return if if_exists && !setting_exists?(self.name, name)
+
+          define! ChangeSettingDefinition, new_setting_definition(name, value, **options, &block)
+        end
+
+        def delete_setting(name, if_exists: false, **options, &block)
+          return if if_exists && !setting_exists?(self.name, name)
+
+          define! DeleteSettingDefinition, new_setting_definition(name, nil, **options, &block)
+        end
+
+        def add_alias(name, if_not_exists: false, **options, &block)
+          return if if_not_exists && alias_exists?(self.name, name)
+
+          define! AddAliasDefinition, new_alias_definition(name, **options, &block)
+        end
+
+        def change_alias(name, if_exists: false, **options, &block)
+          return if if_exists && !alias_exists?(self.name, name)
+
+          define! ChangeAliasDefinition, new_alias_definition(name, **options, &block)
+        end
+
+        def delete_alias(name, if_exists: false, **, &block)
+          return if if_exists && !alias_exists?(self.name, name)
+
+          define! DeleteAliasDefinition, new_alias_definition(name, &block)
+        end
+
+        # Appends <tt>:datetime</tt> columns <tt>:created_at</tt> and
+        # <tt>:updated_at</tt> to the table. See {connection.add_timestamps}[rdoc-ref:SchemaStatements#add_timestamps]
+        #
+        #   t.timestamps
+        def timestamps(**options)
+          add_mapping(:created_at, :datetime, if_not_exists: true, **options)
+          add_mapping(:updated_at, :datetime, if_not_exists: true, **options)
+        end
+
+        private
+
+        def define!(klass, item)
+          @definitions        ||= {}
+          @definitions[klass] ||= []
+          @definitions[klass] << item
+        end
+
+        def _before_assign
+          # check, if the table should be closed before executing the queries
+          close_table(self.name) if _toggle_table_status?
+
+          # reset table state
+          clear_state!
+        end
+
+        def _after_assign
+          # run the same content as +_after_exec+, but only if the assignment failed
+          _after_exec if failed?
+        end
+
+        def _after_exec
+          # reopen the table again
+          open_table(self.name) if _toggle_table_status?
+
+          # reset table state
+          clear_state!
+        end
+
+        def _toggle_table_status?
+          @toggle_table_status = (force? && state[:status] == 'open') if @toggle_table_status.nil?
+
+          @toggle_table_status
+        end
+
+        def _exec
+          return unless definitions.any?
+
+          # check, if the table should be closed before executing the queries
+          close_table(self.name) if opts[:close] == true
+
+          definitions.each do |klass, items|
+            # check if the provided definition klass is a composite definition
+            executable_definitions = if COMPOSITE_DEFINITIONS.include?(klass)
+                                       [InterlacedUpdateTableDefinition.new(name, klass.new(items))]
+                                     else
+                                       items.map { |d|
+                                         InterlacedUpdateTableDefinition.new(name, klass.new(d))
+                                       }
+                                     end
+
+            executable_definitions.each do |ed|
+              execute(schema_creation.accept(ed), _to_composite_log(klass))
+            end
+          end
+
+          open_table(self.name) if opts[:close] == true
+
+          # cleanup definitions
+          @definitions = {}
+        end
+
+        def _to_composite_log(klass)
+          klass.name.demodulize.underscore.gsub(/_definition/, '').gsub(/_/, ' ').upcase
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Elasticsearch
+      # interlaced / nested definition to handle multiple grouped definitions
+      InterlacedUpdateTableDefinition = Struct.new(:name, :definition)
+
+      # mapping definitions
+      AddMappingDefinition    = Struct.new(:items) # composite
+      ChangeMappingDefinition = Struct.new(:items) # composite
+
+      # setting definitions
+      AddSettingDefinition    = Struct.new(:items) # composite
+      ChangeSettingDefinition = Struct.new(:items) # composite
+      DeleteSettingDefinition = Struct.new(:items) # composite
+
+      # alias definitions
+      AddAliasDefinition    = Struct.new(:item) # single
+      ChangeAliasDefinition = Struct.new(:item) # single
+      DeleteAliasDefinition = Struct.new(:items) # composite
+    end
+  end
+end
+
+# WARNING: the loading order is mandatory and must not be changed
+# ALSO: the requirements have to be below the upper definitions
+require 'active_record/connection_adapters/elasticsearch/schema_definitions/attribute_methods'
+require 'active_record/connection_adapters/elasticsearch/schema_definitions/column_methods'
+
+require 'active_record/connection_adapters/elasticsearch/schema_definitions/table_alias_definition'
+require 'active_record/connection_adapters/elasticsearch/schema_definitions/table_mapping_definition'
+require 'active_record/connection_adapters/elasticsearch/schema_definitions/table_setting_definition'
+
+require 'active_record/connection_adapters/elasticsearch/schema_definitions/table_definition'
+require 'active_record/connection_adapters/elasticsearch/schema_definitions/create_table_definition'
+require 'active_record/connection_adapters/elasticsearch/schema_definitions/update_table_definition'