elasticsearch_record 1.2.3 → 1.3.0

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

@@ -11,6 +11,7 @@ module ActiveRecord
           # ORIGINAL methods untouched:
           #
           # SUPPORTED but not used:
+          # -
           #
           # UNSUPPORTED methods that will be ignored:
           # - native_database_types
@@ -25,11 +26,6 @@ module ActiveRecord
           # - change_column_default
           # - change_column_null
           # - rename_column
-          #
-          # UPCOMING future methods:
-          # - clone (option -> close, or read-only (#lock / unlock) )
-          # - refresh
-          # - rename_table
 
           define_unsupported_method :create_join_table, :drop_join_table, :create_alter_table,
                                     :change_column_default, :change_column_null, :rename_column, :rename_table
@@ -70,6 +66,26 @@ module ActiveRecord
             table_names.map { |table_name| close_table(table_name) }
           end
 
+          # refresh an index.
+          # A refresh makes recent operations performed on one or more indices available for search.
+          # raises an exception if the index could not be found.
+          #
+          # @param [String] table_name
+          # @return [Boolean] result state (returns false if refreshing failed)
+          def refresh_table(table_name)
+            api(:indices, :refresh, { index: table_name }, 'REFRESH TABLE').dig('_shards','failed') == 0
+          end
+
+          # refresh indices by provided names.
+          # @param [Array] table_names
+          # @return [Array] result state (returns false if refreshing failed)
+          def refresh_tables(*table_names)
+            table_names -= [schema_migration.table_name, InternalMetadata.table_name]
+            return if table_names.empty?
+
+            table_names.map { |table_name| refresh_table(table_name) }
+          end
+
           # truncates index by provided name.
           # HINT: Elasticsearch does not have a +truncate+ concept:
           # - so we have to store the current index' schema
@@ -132,15 +148,14 @@ module ActiveRecord
             end
           end
 
-          # clones an entire table to the provided +target_name+.
+          # clones an entire table (index) to the provided +target_name+.
           # During cloning, the table will be automatically 'write'-blocked.
           # @param [String] table_name
           # @param [String] target_name
           # @param [Hash] options
-          # @param [Proc] block
-          def clone_table(table_name, target_name, **options, &block)
+          def clone_table(table_name, target_name, **options)
             # create new definition
-            definition = clone_table_definition(table_name, target_name, **extract_table_options!(options), &block)
+            definition = clone_table_definition(table_name, target_name, **extract_table_options!(options))
 
             # yield optional block
             if block_given?
@@ -153,6 +168,24 @@ module ActiveRecord
             definition.exec!
           end
 
+          # renames a table (index) by executing multiple steps:
+          # - clone table
+          # - wait for 'green' state
+          # - drop old table
+          # The +timeout+ option will define how long to wait for the 'green' state.
+          #
+          # @param [String] table_name
+          # @param [String] target_name
+          # @param [String (frozen)] timeout (default: '30s')
+          # @param [Hash] options - additional 'clone' options (like settings, alias, ...)
+          def rename_table(table_name, target_name, timeout: '30s', **options)
+            schema_cache.clear_data_source_cache!(table_name)
+
+            clone_table(table_name, target_name, **options)
+            cluster_health(index: target_name, wait_for_status: 'green', timeout: timeout)
+            drop_table(table_name)
+          end
+
           # creates a new table (index).
           # [<tt>:force</tt>]
           #   Set to +true+ to drop an existing table
@@ -168,9 +201,6 @@ module ActiveRecord
           # @param [Hash] options
           # @return [Boolean] acknowledged status
           def create_table(table_name, force: false, copy_from: nil, if_not_exists: false, **options)
-            # IMPORTANT: compute will add possible configured prefix & suffix
-            table_name = compute_table_name(table_name)
-
             return if if_not_exists && table_exists?(table_name)
 
             # copy schema from existing table
@@ -204,12 +234,14 @@ module ActiveRecord
           #     t.mapping :name, :string
           #     # Other column alterations here
           #   end
-          def change_table(table_name, if_exists: false, **options)
-            # IMPORTANT: compute will add possible configured prefix & suffix
-            table_name = compute_table_name(table_name)
-
+          def change_table(table_name, if_exists: false, recreate: false, **options, &block)
             return if if_exists && !table_exists?(table_name)
 
+            # check 'recreate' flag.
+            # If true, a 'create_table' with copy of the current will be executed
+            return create_table(table_name, force: true, copy_from: table_name, **options, &block) if recreate
+
+            # build new update definition
             definition = update_table_definition(table_name, self, **options)
 
             # yield optional block
@@ -231,12 +263,19 @@ module ActiveRecord
 
           alias :add_column :add_mapping
 
+          # will fail unless +recreate:true+ option was provided
           def change_mapping(table_name, name, type, **options, &block)
             _exec_change_table_with(:change_mapping, table_name, name, type, **options, &block)
           end
 
           alias :change_column :change_mapping
 
+          def remove_mapping(table_name, name, **options)
+            _exec_change_table_with(:remove_mapping, table_name, name, **options)
+          end
+
+          alias :remove_column :remove_mapping
+
           def change_mapping_meta(table_name, name, **options)
             _exec_change_table_with(:change_mapping_meta, table_name, name, **options)
           end
@@ -245,14 +284,12 @@ module ActiveRecord
             _exec_change_table_with(:change_mapping_attributes, table_name, name, **options, &block)
           end
 
-          alias :change_mapping_attribute :change_mapping_attributes
-
           def change_meta(table_name, name, value, **options)
             _exec_change_table_with(:change_meta, table_name, name, value, **options)
           end
 
-          def delete_meta(table_name, name, **options)
-            _exec_change_table_with(:delete_meta, table_name, name, **options)
+          def remove_meta(table_name, name, **options)
+            _exec_change_table_with(:remove_meta, table_name, name, **options)
           end
 
           # -- setting -------------------------------------------------------------------------------------------------
@@ -265,8 +302,8 @@ module ActiveRecord
             _exec_change_table_with(:change_setting, table_name, name, value, **options, &block)
           end
 
-          def delete_setting(table_name, name, **options, &block)
-            _exec_change_table_with(:delete_setting, table_name, name, **options, &block)
+          def remove_setting(table_name, name, **options, &block)
+            _exec_change_table_with(:remove_setting, table_name, name, **options, &block)
           end
 
           # -- alias ---------------------------------------------------------------------------------------------------
@@ -279,28 +316,31 @@ module ActiveRecord
             _exec_change_table_with(:change_alias, table_name, name, **options, &block)
           end
 
-          def delete_alias(table_name, name, **options, &block)
-            _exec_change_table_with(:delete_alias, table_name, name, **options, &block)
+          def remove_alias(table_name, name, **options, &block)
+            _exec_change_table_with(:remove_alias, table_name, name, **options, &block)
           end
 
-          # computes a provided +table_name+ with optionally configured +table_name_prefix+ & +table_name_suffix+.
+          # recaps a provided +table_name+ with optionally configured +table_name_prefix+ & +table_name_suffix+.
+          # This depends on the connection config of the current environment.
+          #
           # @param [String] table_name
           # @return [String]
-          def compute_table_name(table_name)
+          def _env_table_name(table_name)
             table_name = table_name.to_s
-            
+
             # HINT: +"" creates a new +unfrozen+ string!
-            str = +""
-            str << table_name_prefix unless table_name.start_with?(table_name_prefix)
-            str << table_name
-            str << table_name_suffix unless table_name.end_with?(table_name_suffix)
-            str
+            name = +""
+            name << table_name_prefix unless table_name.start_with?(table_name_prefix)
+            name << table_name
+            name << table_name_suffix unless table_name.end_with?(table_name_suffix)
+
+            name
           end
 
           private
 
-          def _exec_change_table_with(method, table_name, *args, **kwargs, &block)
-            change_table(table_name) do |t|
+          def _exec_change_table_with(method, table_name, *args, recreate: false, **kwargs, &block)
+            change_table(table_name, recreate: recreate) do |t|
               t.send(method, *args, **kwargs, &block)
             end
           end

data/lib/arel/collectors/elasticsearch_query.rb

@@ -9,6 +9,9 @@ module Arel # :nodoc: all
       # required for ActiveRecord
       attr_accessor :preparable
 
+      # returns the current bind index (default: 1)
+      attr_reader :bind_index
+
       def initialize
         # force initialize a body as hash
         super(body: {})
@@ -44,7 +47,8 @@ module Arel # :nodoc: all
           # adds / sets any argument
           if args.length == 2
             @arguments[args[0]] = args[1]
-          else # should be a hash
+          else
+            # should be a hash
             @arguments.merge!(args[0])
           end
         when :body
@@ -90,10 +94,13 @@ module Arel # :nodoc: all
 
       private
 
-      # calls a assign on the body
+      # calls a assign on the body.
+      # forwards value to the +#claim+ method if key is +:__query__+.
+      # @param [Symbol] key
+      # @param [Object] value
       def assign(key, value)
         # check for special provided key, to claim through an assign
-        if key == :__claim__
+        if key == :__query__
           if value.is_a?(Array)
             value.each do |arg|
               vkey = arg.keys.first

data/lib/arel/visitors/elasticsearch_query.rb

@@ -13,7 +13,7 @@ module Arel # :nodoc: all
 
       # SELECT // SEARCH
       def visit_Arel_Nodes_SelectStatement(o)
-        # prepare query
+        # prepare query type
         claim(:type, ::ElasticsearchRecord::Query::TYPE_SEARCH)
 
         resolve(o.cores) # visit_Arel_Nodes_SelectCore
@@ -26,20 +26,23 @@ module Arel # :nodoc: all
         resolve(o.configure)
       end
 
-      # UPDATE
+      # UPDATE (by query - not a single record...)
       def visit_Arel_Nodes_UpdateStatement(o)
         # switch between updating a single Record or multiple by query
         if o.relation.is_a?(::Arel::Table)
           raise NotImplementedError, "if you've made it this far, something went wrong ..."
         end
 
-        # prepare query
+        # prepare query type
         claim(:type, ::ElasticsearchRecord::Query::TYPE_UPDATE_BY_QUERY)
 
+        # force refresh after update - but it can be unset again through the 'configure' ...
+        claim(:refresh, true)
+
         # sets the index
         resolve(o.relation)
 
-        # updating multiple entries need a script
+        # updating multiple entries needs a script
         assign(:script, {}) do
           assign(:inline, "") do
             updates = collect(o.values)
@@ -59,16 +62,19 @@ module Arel # :nodoc: all
         resolve(o.configure)
       end
 
-      # DELETE
+      # DELETE (by query - not a single record...)
       def visit_Arel_Nodes_DeleteStatement(o)
         # switch between updating a single Record or multiple by query
         if o.relation.is_a?(::Arel::Table)
           raise NotImplementedError, "if you've made it this far, something went wrong ..."
         end
 
-        # prepare query
+        # prepare query type
         claim(:type, ::ElasticsearchRecord::Query::TYPE_DELETE_BY_QUERY)
 
+        # force refresh after delete - but it can be unset again through the 'configure' ...
+        claim(:refresh, true)
+
         # sets the index
         resolve(o.relation)
 
@@ -84,13 +90,15 @@ module Arel # :nodoc: all
         resolve(o.configure)
       end
 
-      # INSERT
+      # INSERT (by query - not a single record...)
+      # this is also used by 'meta' or 'schema_migrations' tables ...
       def visit_Arel_Nodes_InsertStatement(o)
-
         # switch between updating a single Record or multiple by query
         if o.relation.is_a?(::Arel::Table)
-          # prepare query
+          # prepare query type
           claim(:type, ::ElasticsearchRecord::Query::TYPE_CREATE)
+
+          # force refresh after insert
           claim(:refresh, true)
 
           # sets the index
@@ -355,6 +363,23 @@ module Arel # :nodoc: all
         end
       end
 
+      # DIRECT ASSIGNMENT
+      def visit_Arel_Nodes_In(o)
+        self.collector.preparable = false
+
+        attr, values = o.left, o.right
+
+        if Array === values
+          unless values.empty?
+            values.delete_if { |value| unboundable?(value) }
+          end
+
+          return failed! if values.empty?
+        end
+
+        assign(:filter, [{ terms: { visit(attr) => visit(values) } }])
+      end
+
       def visit_Arel_Nodes_And(o)
         collect(o.children)
       end
@@ -393,6 +418,7 @@ module Arel # :nodoc: all
         claim(:index, o.name)
       end
 
+      # RAW RETURN
       def visit_Struct_Raw(o)
         o
       end

data/lib/arel/visitors/elasticsearch_schema.rb

@@ -89,8 +89,9 @@ module Arel # :nodoc: all
         # prepare query
         claim(:type, ::ElasticsearchRecord::Query::TYPE_INDEX_UPDATE_SETTING)
 
-        # special overcomplicated blocks to assign a hash of settings directly to the body
-        assign(:__claim__, {}) do
+        # special overcomplicated blocks to assign a hash of settings directly to the body...
+        # todo: refactor this in future versions
+        assign(:__query__, {}) do
           assign(:body, {}) do
             resolve(o.items, :visit_TableSettingDefinition)
           end
@@ -98,7 +99,7 @@ module Arel # :nodoc: all
       end
 
       alias :visit_AddSettingDefinition :visit_ChangeSettingDefinition
-      alias :visit_DeleteSettingDefinition :visit_ChangeSettingDefinition
+      alias :visit_RemoveSettingDefinition :visit_ChangeSettingDefinition
 
       def visit_ChangeAliasDefinition(o)
         # prepare query
@@ -110,7 +111,7 @@ module Arel # :nodoc: all
 
       alias :visit_AddAliasDefinition :visit_ChangeAliasDefinition
 
-      def visit_DeleteAliasDefinition(o)
+      def visit_RemoveAliasDefinition(o)
         # prepare query
         claim(:type, ::ElasticsearchRecord::Query::TYPE_INDEX_DELETE_ALIAS)
 

data/lib/elasticsearch_record/gem_version.rb

@@ -8,8 +8,8 @@ module ElasticsearchRecord
 
   module VERSION
     MAJOR = 1
-    MINOR = 2
-    TINY  = 3
+    MINOR = 3
+    TINY  = 0
     PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")

data/lib/elasticsearch_record/relation/calculation_methods.rb

@@ -33,9 +33,9 @@ module ElasticsearchRecord
           # since total will be limited to 10000 results, we need to resolve the real values by a custom query.
           # This query is called through +#select_count+.
           #
-          # HINT: :__claim__ directly interacts with the query-object and sets a 'terminate_after' argument
-          # (see @ Arel::Collectors::ElasticsearchQuery#assign)
-          arel = spawn.unscope!(:offset, :limit, :order, :configure, :aggs).configure!(:__claim__, argument: { terminate_after: limit_value }).arel
+          # HINT: +:__query__+ directly interacts with the query-object and sets the 'terminate_after' argument
+          # see @ ElasticsearchRecord::Query#arguments & Arel::Collectors::ElasticsearchQuery#assign
+          arel = spawn.unscope!(:offset, :limit, :order, :configure, :aggs).configure!(:__query__, argument: { terminate_after: limit_value }).arel
           klass.connection.select_count(arel, "#{klass.name} Count")
         else
           # since total will be limited to 10000 results, we need to resolve the real values by a custom query.

data/lib/elasticsearch_record/relation/query_methods.rb

@@ -27,9 +27,12 @@ module ElasticsearchRecord
         self
       end
 
-      # sets or overwrites additional arguments for the query (not the :query-node, the whole query).
-      # You can also force a overwrite of previously defined arguments, like +size+ or +from+.
-      # This is useful to force remove of keys.
+      # sets or overwrites additional arguments for the whole query (not the current 'query-node' - the whole query).
+      # Previously defined arguments (like +size+ or +from+) can also be overwritten.
+      # Providing a +nil+ value will remove the key  - this is useful to force remove of keys.
+      #
+      # Providing the special key +:__query__+ will directly access the query object, to alter query-related values
+      # (like 'refresh, arguments, columns, ...' - see @ Arel::Collectors::ElasticsearchQuery
       #
       # @example
       #   # adds {refresh true} to the query
@@ -37,6 +40,10 @@ module ElasticsearchRecord
       #
       #   # overwrites or sets {from: 50} but removes the :sort key
       #   configure({from: 50, sort: nil})
+      #
+      #   # sets the query's 'refresh' to true
+      #   configure(:__query__, refresh: true)
+      #
       # @param [Array] args
       def configure(*args)
         spawn.configure!(*args)
@@ -48,10 +55,10 @@ module ElasticsearchRecord
 
         if args.length == 1 && args.first.is_a?(Hash)
           self.configure_value = self.configure_value.merge(args[0])
-        elsif args.length == 2 && args[0] == :__claim__
-          tmp = self.configure_value[:__claim__] || []
+        elsif args.length == 2 && args[0] == :__query__
+          tmp = self.configure_value[:__query__] || []
           tmp << args[1]
-          self.configure_value = self.configure_value.merge(:__claim__ => tmp)
+          self.configure_value = self.configure_value.merge(:__query__ => tmp)
         elsif args.length == 2
           self.configure_value = self.configure_value.merge(args[0] => args[1])
         end
@@ -69,7 +76,8 @@ module ElasticsearchRecord
 
       alias_method :aggs, :aggregate
 
-      def aggregate!(opts, *rest) # :nodoc:
+      def aggregate!(opts, *rest)
+        # :nodoc:
         case opts
         when Symbol, String
           self.aggs_clause += build_query_clause(opts, rest)
@@ -84,6 +92,16 @@ module ElasticsearchRecord
         self
       end
 
+      # sets the query's +refresh+ value.
+      # @param [Boolean] value (default: true)
+      def refresh(value = true)
+        spawn.refresh!(value)
+      end
+
+      def refresh!(value = true)
+        configure!(:__query__, refresh: value)
+      end
+
       # add a whole query 'node' to the query.
       # @example
       #   query(:bool, {filter: ...})
@@ -92,7 +110,8 @@ module ElasticsearchRecord
         spawn.query!(*args)
       end
 
-      def query!(kind, opts, *rest) # :nodoc:
+      def query!(kind, opts, *rest)
+        # :nodoc:
         kind!(kind)
         self.query_clause += build_query_clause(opts.keys[0], opts.values[0], rest)
         self
@@ -106,7 +125,8 @@ module ElasticsearchRecord
         spawn.filter!(*args)
       end
 
-      def filter!(opts, *rest) # :nodoc:
+      def filter!(opts, *rest)
+        # :nodoc:
         set_default_kind!
         self.query_clause += build_query_clause(:filter, opts, rest)
         self
@@ -120,7 +140,8 @@ module ElasticsearchRecord
         spawn.must_not!(*args)
       end
 
-      def must_not!(opts, *rest) # :nodoc:
+      def must_not!(opts, *rest)
+        # :nodoc:
         set_default_kind!
         self.query_clause += build_query_clause(:must_not, opts, rest)
         self
@@ -134,7 +155,8 @@ module ElasticsearchRecord
         spawn.must!(*args)
       end
 
-      def must!(opts, *rest) # :nodoc:
+      def must!(opts, *rest)
+        # :nodoc:
         set_default_kind!
         self.query_clause += build_query_clause(:must, opts, rest)
         self
@@ -148,7 +170,8 @@ module ElasticsearchRecord
         spawn.should!(*args)
       end
 
-      def should!(opts, *rest) # :nodoc:
+      def should!(opts, *rest)
+        # :nodoc:
         set_default_kind!
         self.query_clause += build_query_clause(:should, opts, rest)
         self
@@ -176,7 +199,8 @@ module ElasticsearchRecord
         super
       end
 
-      def where!(opts, *rest) # :nodoc:
+      def where!(opts, *rest)
+        # :nodoc:
         case opts
           # check the first provided parameter +opts+ and validate, if this is an alias for "must, must_not, should or filter"
           # if true, we expect the rest[0] to be a hash.
@@ -186,7 +210,7 @@ module ElasticsearchRecord
           when :filter, :must, :must_not, :should
             send("#{opts}!", *rest)
           else
-            raise ArgumentError, "Unsupported argument type for where: #{opts}"
+            raise ArgumentError, "Unsupported prefix type '#{opts}'. Allowed types are: :filter, :must, :must_not, :should"
           end
         when Array
           # check if this is a nested array of multiple [<kind>,<data>]
@@ -197,42 +221,8 @@ module ElasticsearchRecord
           else
             where!(*opts, *rest)
           end
-        when String
-          # fallback to ActiveRecords +#where_clause+
-          # currently NOT supported
-          super(opts, rest)
         else
-          # hash -> {name: 'hans'}
-          # protects against forwarding params directly to where ...
-          # User.where(params) <- will never work
-          # User.where(params.permit(:user)) <- ok
-          opts = sanitize_forbidden_attributes(opts)
-
-          # resolve possible aliases
-          opts = opts.transform_keys do |key|
-            key = key.to_s
-            klass.attribute_aliases[key] || key
-          end
-
-          # check if we have keys without Elasticsearch fields
-          if (invalid = (opts.keys - klass.searchable_column_names)).present?
-            raise(ActiveRecord::UnknownAttributeReference,
-                  "Unable to build query with unknown searchable attributes: #{invalid.map(&:inspect).join(", ")}. " \
-                "If you want to build a custom query you should use one of those methods: 'filter, must, must_not, should'. " \
-                "#{klass.name}.filter('#{invalid[0]}' => '...')"
-            )
-          end
-
-          # force set default kind, if not previously set
-          set_default_kind!
-
-          # builds predicates from opts (transforms this in a more unreadable way but is required for nested assignment & binds ...)
-          parts = opts.map do |key,value|
-            # builds and returns a new Arel Node from provided key/value pair
-            predicate_builder[key,value]
-          end
-
-          self.where_clause += ::ActiveRecord::Relation::WhereClause.new(parts)
+          self.where_clause += build_where_clause(opts, rest)
         end
 
         self
@@ -271,6 +261,45 @@ module ElasticsearchRecord
 
       private
 
+      def build_where_clause(opts, _rest = [])
+        case opts
+        when Symbol, Array, String
+          raise ArgumentError, "Unsupported or unresolved argument class '#{opts.class}' for build_where_clause: #{opts}"
+        else
+          # hash -> {name: 'hans'}
+          # protects against forwarding params directly to where ...
+          # User.where(params) <- will never work
+          # User.where(params.permit(:user)) <- ok
+          opts = sanitize_forbidden_attributes(opts)
+
+          # resolve possible aliases
+          opts = opts.transform_keys do |key|
+            key = key.to_s
+            klass.attribute_aliases[key] || key
+          end
+
+          # check if we have keys without Elasticsearch fields
+          if (invalid = (opts.keys - klass.searchable_column_names)).present?
+            raise(ActiveRecord::UnknownAttributeReference,
+                  "Unable to build query with unknown searchable attributes: #{invalid.map(&:inspect).join(", ")}. " \
+                "If you want to build a custom query you should use one of those methods: 'filter, must, must_not, should'. " \
+                "#{klass.name}.filter('#{invalid[0]}' => '...')"
+            )
+          end
+
+          # force set default kind, if not previously set
+          set_default_kind!
+
+          # builds predicates from opts (transforms this in a more unreadable way but is required for nested assignment & binds ...)
+          parts = opts.map do |key, value|
+            # builds and returns a new Arel Node from provided key/value pair
+            predicate_builder[key, value]
+          end
+
+          ::ActiveRecord::Relation::WhereClause.new(parts)
+        end
+      end
+
       def build_query_clause(kind, data, rest = [])
         ElasticsearchRecord::Relation::QueryClause.new(kind, Array.wrap(data), rest.extract_options!)
       end

data/lib/elasticsearch_record/relation/result_methods.rb

@@ -104,7 +104,7 @@ module ElasticsearchRecord
         relation.offset!(nil).limit!(nil)
 
         # remove the 'index' from the query arguments (pit doesn't like that)
-        relation.configure!(:__claim__, { index: nil })
+        relation.configure!(:__query__, { index: nil })
 
         # we store the results in this array
         results       = []