elasticsearch_record 1.0.2 → 1.1.0

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

@@ -3,144 +3,161 @@
 module ActiveRecord
   module ConnectionAdapters
     module Elasticsearch
+      # extend adapter with query-related statements
+      #
+      # *ORIGINAL* methods untouched:
+      # - to_sql
+      # - to_sql_and_binds
+      # - insert
+      # - create
+      # - update
+      # - delete
+      # - arel_from_relation
+      #
+      # *SUPPORTED* but not used:
+      # - select
+      # - select_all
+      # - select_one
+      # - select_value
+      # - select_values
+      #
+      # *UNSUPPORTED* methods that will be +ignored+:
+      # - build_fixture_sql
+      # - build_fixture_statements
+      # - build_truncate_statement
+      # - build_truncate_statements
+      #
+      # *UNSUPPORTED* methods that will +fail+:
+      # - insert_fixture
+      # - insert_fixtures_set
+      # - execute_batch
+      # - select_prepared
+      # - combine_multi_statements
+      #
       module DatabaseStatements
+        extend ActiveSupport::Concern
+
+        included do
+          define_unsupported_method :insert_fixture, :insert_fixtures_set, :execute_batch, :select_prepared,
+                                    :combine_multi_statements
+
+          # detects if a query is a write query.
+          # since we don't provide a simple string / hash we can now access the query-object and ask for it :)
+          # @see ActiveRecord::ConnectionAdapters::DatabaseStatements#write_query?
+          # @param [ElasticsearchRecord::Query] query
+          # @return [Boolean]
+          def write_query?(query)
+            query.write?
+          end
 
-        # detects if a query is a write query.
-        # since we don't provide a simple string / hash we can now access the query-object and ask for it :)
-        # @see ActiveRecord::ConnectionAdapters::DatabaseStatements#write_query?
-        # @param [ElasticsearchRecord::Query] query
-        # @return [Boolean]
-        def write_query?(query)
-          query.write?
-        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)] name
+          # @param [Boolean] async
+          # @return [ElasticsearchRecord::Result]
+          def execute(query, name = nil, async: 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?
+
+            # 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
-        # @param [ElasticsearchRecord::Query] query
-        # @param [String (frozen)] name
-        # @param [Array] binds
-        # @param [Boolean] prepare - used by the default AbstractAdapter - but not supported and therefore never used!
-        # @param [Boolean] async
-        # @return [ElasticsearchRecord::Result]
-        def exec_query(query, name = "QUERY", binds = [], prepare: false, async: false)
-          # validate the query
-          raise ActiveRecord::StatementInvalid, 'Unable to execute invalid query' unless query.valid?
-
-          # checks for write query - raises an exception if connection is locked to readonly ...
-          check_if_write_query(query)
-
-          build_result(
-            api(*query.gate, query.query_arguments, name, async: async),
-            columns: query.columns
-          )
-        end
+          # gets called for all queries - a +ElasticsearchRecord::Query+ must be provided.
+          # @param [ElasticsearchRecord::Query] query
+          # @param [String (frozen)] 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 exec_query(query, name = "QUERY", binds = [], prepare: false, async: false)
+            build_result(
+              execute(query, name, async: async),
+              columns: query.columns
+            )
+          end
 
-        # Executes insert +query+ statement in the context of this connection using
-        # +binds+ as the bind substitutes. +name+ is logged along with
-        # the executed +query+ arguments.
-        def exec_insert(query, name = nil, binds = [], _pk = nil, _sequence_name = nil)
-          exec_query(query, name, binds)
-        end
+          # Executes insert +query+ statement in the context of this connection using
+          # +binds+ as the bind substitutes. +name+ is logged along with
+          # the executed +query+ arguments.
+          # @return [ElasticsearchRecord::Result]
+          def exec_insert(query, name = nil, binds = [], _pk = nil, _sequence_name = nil)
+            result = exec_query(query, name, binds)
 
-        # Executes delete +query+ statement in the context of this connection using
-        # +binds+ as the bind substitutes. +name+ is logged along with
-        # the executed +query+ arguments.
-        # expects a integer as return.
-        # @return [Integer]
-        def exec_delete(query, name = nil, binds = [])
-          exec_query(query, name, binds).total
-        end
+            # fetch additional Elasticsearch response result
+            # raise ::ElasticsearchRecord::ResponseResultError.new('created', result.result) unless result.result == 'created'
 
-        # Executes update +query+ statement in the context of this connection using
-        # +binds+ as the bind substitutes. +name+ is logged along with
-        # the executed +query+ arguments.
-        # expects a integer as return.
-        # @return [Integer]
-        def exec_update(query, name = nil, binds = [])
-          exec_query(query, name, binds).total
-        end
+            # return the result object
+            result
+          end
 
-        # executes a msearch for provided arels
-        # @return [ElasticsearchRecord::Result]
-        def select_multiple(arels, name = "Multi", async: false)
-          # transform arels to query objects
-          queries = arels.map { |arel| to_sql(arel_from_relation(arel)) }
+          # Executes update +query+ statement in the context of this connection using
+          # +binds+ as the bind substitutes. +name+ is logged along with
+          # the executed +query+ arguments.
+          # expects a integer as return.
+          # @return [Integer]
+          def exec_update(query, name = nil, binds = [])
+            result = exec_query(query, name, binds)
 
-          # build new msearch query
-          query = ElasticsearchRecord::Query.new(
-            index: queries.first&.index,
-            type:  ElasticsearchRecord::Query::TYPE_MSEARCH,
-            body:  queries.map { |q| { search: q.body } })
+            # fetch additional Elasticsearch response result
+            # raise ::ElasticsearchRecord::ResponseResultError.new('updated', result.result) unless result.result == 'updated'
 
-          exec_query(query, name, async: async)
-        end
+            result.total
+          end
 
-        # executes a count query for provided arel
-        # @return [Integer]
-        def select_count(arel, name = "Count", async: false)
-          query = to_sql(arel_from_relation(arel))
+          # Executes delete +query+ statement in the context of this connection using
+          # +binds+ as the bind substitutes. +name+ is logged along with
+          # the executed +query+ arguments.
+          # expects a integer as return.
+          # @return [Integer]
+          def exec_delete(query, name = nil, binds = [])
+            result = exec_query(query, name, binds)
 
-          # build new count query from existing query
-          query = ElasticsearchRecord::Query.new(
-            index:     query.index,
-            type:      ElasticsearchRecord::Query::TYPE_COUNT,
-            body:      query.body,
-            arguments: query.arguments)
+            # fetch additional Elasticsearch response result
+            # raise ::ElasticsearchRecord::ResponseResultError.new('deleted', result.result) unless result.result == 'deleted'
 
-          exec_query(query, name, async: async).response['count']
-        end
+            result.total
+          end
+
+          # executes a msearch for provided arels
+          # @return [ElasticsearchRecord::Result]
+          def select_multiple(arels, name = "Multi", async: false)
+            # transform arels to query objects
+            queries = arels.map { |arel| to_sql(arel_from_relation(arel)) }
+
+            # build new msearch query
+            query = ElasticsearchRecord::Query.new(
+              index: queries.first&.index,
+              type:  ElasticsearchRecord::Query::TYPE_MSEARCH,
+              body:  queries.map { |q| { search: q.body } })
+
+            exec_query(query, name, async: async)
+          end
+
+          # executes a count query for provided arel
+          # @return [Integer]
+          def select_count(arel, name = "Count", async: false)
+            query = to_sql(arel_from_relation(arel))
+
+            # build new count query from existing query
+            query = ElasticsearchRecord::Query.new(
+              index:     query.index,
+              type:      ElasticsearchRecord::Query::TYPE_COUNT,
+              body:      query.body,
+              status:    query.status,
+              arguments: query.arguments)
+
+            exec_query(query, name, async: async).response['count']
+          end
 
-        # # This is used in the StatementCache object. It returns an object that
-        # # can be used to query the database repeatedly.
-        # # @see ActiveRecord::ConnectionAdapters::DatabaseStatements#cacheable_query
-        # def cacheable_query(klass, arel) # :nodoc:
-        #   # the provided klass is a ActiveRecord::StatementCache and only supports SQL _(String)_ queries.
-        #   # We force overwrite this class with our own
-        #
-        #
-        #   ActiveRecord::StatementCache.partial_query_collector
-        #
-        #   raise "STOP HERE!!!!!!"
-        #   if prepared_statements
-        #     sql, binds = visitor.compile(arel.ast, collector)
-        #     query = klass.query(sql)
-        #   else
-        #     collector = klass.partial_query_collector
-        #     parts, binds = visitor.compile(arel.ast, collector)
-        #     query = klass.partial_query(parts)
-        #   end
-        #   [query, binds]
-        # end
-
-        # calls the +elasticsearch-api+ endpoints by provided namespace and action.
-        # if a block was provided it'll yield the response.body and returns the blocks result.
-        # otherwise it will return the response itself...
-        # @param [Symbol] namespace - the API namespace (e.g. indices, nodes, sql, ...)
-        # @param [Symbol] action - the API action to call in tha namespace
-        # @param [Hash] arguments - action arguments
-        # @param [String (frozen)] name - the logging name
-        # @param [Boolean] async - send async (default: false) - currently not supported
-        # @return [Elasticsearch::API::Response, Object]
-        def api(namespace, action, arguments = {}, name = 'API', async: false)
-          raise ::StandardError, 'ASYNC api calls are not supported' if async
-
-          # resolve the API target
-          target = namespace == :core ? @connection : @connection.__send__(namespace)
-
-          log("#{namespace}.#{action}", arguments, name, async: async) do
-            response = ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-              target.__send__(action, arguments)
-            end
-
-            if response.is_a?(::Elasticsearch::API::Response)
-              # reverse information for the LogSubscriber - shows the 'query-time' in the logs
-              # this works, since we use a referenced hash ...
-              arguments[:_qt] = response['took']
-
-              # raise timeouts
-              raise(ActiveRecord::StatementTimeout, "Elasticsearch api request failed due a timeout") if response['timed_out']
-            end
-
-            response
+          # returns the last inserted id from the result.
+          # called through +#insert+
+          def last_inserted_id(result)
+            result.response['_id']
           end
         end
       end

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

@@ -4,33 +4,12 @@ module ActiveRecord
   module ConnectionAdapters
     module Elasticsearch
       module Quoting # :nodoc:
-        # Quotes the column value to help prevent
-        def quote(value)
-          case value
-            # those values do not need to be quoted
-          when BigDecimal, Numeric, String, Symbol, nil, true, false then value
-          when ActiveSupport::Duration then value.to_i
-          when Array then value.map { |val| quote(val) }
-          when Hash then value.transform_values { |val| quote(val) }
-          else
-            super
-          end
-        end
-
         def quoted_true
-          true
-        end
-
-        def unquoted_true
-          true
+          'true'
         end
 
         def quoted_false
-          false
-        end
-
-        def unquoted_false
-          false
+          'false'
         end
       end
     end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Elasticsearch
+      # this class is totally refactored from the original and acts here as "wrapper"
+      # - to support rails backwards compatibility on the +#schema_creation+ method
+      class SchemaCreation # :nodoc:
+
+        attr_reader :connection
+
+        def initialize(connection)
+          @connection = connection
+        end
+
+        def accept(o)
+          visitor.dispatch_as(:simple) do
+            visitor.compile(o)
+          end
+        end
+
+        private
+
+        def visitor
+          @visitor ||= connection.visitor
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Elasticsearch
+      module AttributeMethods
+        extend ActiveSupport::Concern
+
+        included do
+          attr_reader :state
+
+          def error_messages
+            errors.full_messages.join(', ')
+          end
+
+          def with_state(state)
+            @state = state
+
+            self
+          end
+
+          def state?
+            state.present?
+          end
+
+          private
+
+          def __set_attribute(key, value)
+            if value.nil?
+              __remove_attribute(key)
+            elsif value.is_a?(Array) || value.is_a?(Hash)
+              @attributes[key] = value.compact
+            else
+              @attributes[key] = value
+            end
+          end
+
+          def __get_attribute(key)
+            @attributes[key]
+          end
+
+          def __remove_attribute(key)
+            @attributes.delete(key)
+          end
+
+          def __set_nested(attr, key, value)
+            values = self.send(attr).presence || {}
+
+            if value.nil?
+              values.delete(key)
+            else
+              values[key.to_s] = value
+            end
+            self.send("#{attr}=", values)
+          end
+
+          def __get_nested(attr, key)
+            values = self.send(attr).presence || {}
+            values[key.to_s]
+          end
+
+          def __attributes_keys
+            @attributes.keys
+          end
+
+          def __attributes_values
+            @attributes.values
+          end
+
+          def __assign(attributes)
+            attributes.each do |key, value|
+              send("#{key}=", value)
+            end
+          end
+
+          def invalid!(message, key = :base)
+            errors.add(key, message)
+            false
+          end
+        end
+
+        class_methods do
+          def build_attribute_methods!(*args)
+            opts       = args.extract_options!
+            opts[:key] ||= :attributes
+
+            args.each do |name|
+              class_eval <<-CODE, __FILE__, __LINE__ + 1
+                def #{name}
+                  __get_attribute(:#{name})
+                end
+      
+                def #{name}=(value)
+                  __set_attribute(:#{name}, value)
+                end
+              CODE
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Elasticsearch
+      module ColumnMethods
+        extend ActiveSupport::Concern
+
+        included do
+          # see @ ::ActiveRecord::ConnectionAdapters::ElasticsearchAdapter::NATIVE_DATABASE_TYPES.keys
+          define_column_methods :string, :blob, :datetime, :bigint, :json, :binary, :boolean, :keyword,
+                                :constant_keyword, :wildcard, :long, :integer, :short, :byte, :double, :float,
+                                :half_float, :scaled_float, :unsigned_long, :date, :object, :flattened, :nested,
+                                :integer_range, :float_range, :long_range, :double_range, :date_range, :ip_range,
+                                :ip, :version, :text
+
+          # Appends a primary key definition to the table definition.
+          # Can be called multiple times, but this is probably not a good idea.
+          def primary_key(name, type = :primary_key, **options)
+            mapping(name, type, **options.merge(primary_key: true))
+          end
+        end
+
+        class_methods do
+          def define_column_methods(*column_types)
+            # :nodoc:
+            column_types.each do |column_type|
+              module_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{column_type}(*names, **options)
+                raise ArgumentError, "Missing column name(s) for #{column_type}" if names.empty?
+                names.each { |name| mapping(name, :#{column_type}, **options) }
+              end
+              RUBY
+            end
+          end
+
+          private :define_column_methods
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require 'active_record/connection_adapters/elasticsearch/schema_definitions/table_definition'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Elasticsearch
+      class CreateTableDefinition < TableDefinition
+        def initialize(conn, name, settings: nil, mappings: nil, aliases: nil, **opts)
+          super(conn, name, **opts)
+
+          @settings = HashWithIndifferentAccess.new
+          @mappings = HashWithIndifferentAccess.new
+          @aliases  = HashWithIndifferentAccess.new
+
+          transform_settings!(settings) if settings.present?
+          transform_mappings!(mappings) if mappings.present?
+          transform_aliases!(aliases) if aliases.present?
+        end
+
+        # returns an array with all +TableSettingDefinition+.
+        # @return [Array]
+        def settings
+          @settings.values
+        end
+
+        # returns an array with all +TableMappingDefinition+.
+        # @return [Array]
+        def mappings
+          @mappings.values
+        end
+
+        # provide backwards compatibility to columns
+        alias columns mappings
+
+        # returns an array with all +TableAliasDefinition+.
+        # @return [Array]
+        def aliases
+          @aliases.values
+        end
+
+        # Returns a MappingDefinition for the mapping with name +name+.
+        def [](name)
+          @mappings[name]
+        end
+
+        ######################
+        # DEFINITION METHODS #
+        ######################
+
+        # adds a new mapping
+        def mapping(name, type, force: false, **options, &block)
+          raise ArgumentError, "you cannot define an already defined mapping '#{name}'!" if @mappings.key?(name) && !force?(force)
+
+          @mappings[name] = new_mapping_definition(name, type, **options, &block)
+
+          self
+        end
+
+        # provide backwards compatibility to columns
+        alias column mapping
+
+        def remove_mapping(name)
+          @mappings.delete(name)
+        end
+
+        # provide backwards compatibility to columns
+        alias remove_column remove_mapping
+
+        def setting(name, value, force: false, **options, &block)
+          raise ArgumentError, "you cannot define an already defined setting '#{name}'!" if @settings.key?(name) && !force?(force)
+
+          @settings[name] = new_setting_definition(name, value, **options, &block)
+
+          self
+        end
+
+        def remove_setting(name)
+          @settings.delete name
+        end
+
+        # we can use +alias+ here, since the instance method is not a reserved keyword!
+
+        def alias(name, force: false, **options, &block)
+          raise ArgumentError, "you cannot define an already defined alias '#{name}'." if @aliases.key?(name) && !force?(force)
+
+          @aliases[name] = new_alias_definition(name, **options, &block)
+
+          self
+        end
+
+        def remove_alias(name)
+          @aliases.delete name
+        end
+
+        # Adds a reference.
+        #
+        #  t.references(:user)
+        #  t.belongs_to(:supplier)
+        #
+        # See {connection.add_reference}[rdoc-ref:SchemaStatements#add_reference] for details of the options you can use.
+        def references(*args, **options)
+          args.each do |ref_name|
+            ActiveRecord::ConnectionAdapters::ReferenceDefinition.new(ref_name, **options).add_to(self)
+          end
+        end
+
+        alias :belongs_to :references
+
+        # 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)
+          column(:created_at, :datetime, **options)
+          column(:updated_at, :datetime, **options)
+        end
+
+        private
+
+        def _exec
+          execute(schema_creation.accept(self), 'CREATE TABLE').dig('acknowledged')
+        end
+
+        # force empty states to prevent "Name is static for an open table" error.
+        def state
+          nil
+        end
+
+        def transform_mappings!(mappings)
+          return unless mappings['properties'].present?
+
+          mappings['properties'].each do |name, attributes|
+            self.mapping(name, attributes.delete('type'), **attributes)
+          end
+        end
+
+        def transform_settings!(settings)
+          # exclude settings, that are provided through the API but are not part of the index-settings
+          settings
+            .with_indifferent_access
+            .each { |name, value|
+              # don't transform ignored names
+              next if ActiveRecord::ConnectionAdapters::Elasticsearch::TableSettingDefinition.match_ignore_names?(name)
+
+              self.setting(name, value)
+            }
+        end
+
+        def transform_aliases!(aliases)
+          aliases.each do |name, attributes|
+            self.alias(name, **attributes)
+          end
+        end
+      end
+    end
+  end
+end