elasticsearch-api 0.0.2

data/lib/elasticsearch/api/actions/indices/validate_query.rb

@@ -0,0 +1,68 @@
+module Elasticsearch
+  module API
+    module Indices
+      module Actions
+
+        # Validate a query
+        #
+        # @example Validate a simple query string query
+        #
+        #     client.indices.validate_query index: 'myindex', q: 'title:foo AND body:bar'
+        #
+        # @example Validate an invalid query (with explanation)
+        #
+        #     client.indices.validate_query index: 'myindex', q: '[[[ BOOM! ]]]', explain: true
+        #
+        # @example Validate a DSL query (with explanation)
+        #
+        #     client.indices.validate_query index: 'myindex',
+        #                                   explain: true,
+        #                                   body: {
+        #                                     filtered: {
+        #                                       query: {
+        #                                         match: {
+        #                                           title: 'foo'
+        #                                         }
+        #                                       },
+        #                                       filter: {
+        #                                         range: {
+        #                                           published_at: {
+        #                                             from: '2013-06-01'
+        #                                           }
+        #                                         }
+        #                                       }
+        #                                     }
+        #                                   }
+        #
+        # @option arguments [List] :index A comma-separated list of index names to restrict the operation;
+        #                                 use `_all` or empty string to perform the operation on all indices
+        # @option arguments [List] :type A comma-separated list of document types to restrict the operation;
+        #                                leave empty to perform the operation on all types
+        # @option arguments [Hash] :body The query definition (*without* the top-level `query` element)
+        # @option arguments [Boolean] :explain Return detailed information about the error
+        # @option arguments [String] :ignore_indices When performed on multiple indices, allows to ignore `missing` ones
+        #                                            (options: none, missing)
+        # @option arguments [String] :source The URL-encoded query definition (instead of using the request body)
+        # @option arguments [String] :q Query in the Lucene query string syntax
+        #
+        # @see http://www.elasticsearch.org/guide/reference/api/validate/
+        #
+        def validate_query(arguments={})
+          method = 'GET'
+          path   = Utils.__pathify( Utils.__listify(arguments[:index]), Utils.__listify(arguments[:type]), '_validate/query' )
+          params = arguments.select do |k,v|
+            [ :q,
+              :explain,
+              :ignore_indices,
+              :source ].include?(k)
+          end
+          # Normalize Ruby 1.8 and Ruby 1.9 Hash#select behaviour
+          params = Hash[params] unless params.is_a?(Hash)
+          body   = arguments[:body]
+
+          perform_request(method, path, params, body).body
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/api/actions/info.rb

@@ -0,0 +1,19 @@
+module Elasticsearch
+  module API
+    module Actions
+
+      # Return simple information about the cluster (name, version).
+      #
+      # @see http://elasticsearch.org/guide/
+      #
+      def info(arguments={})
+        method = 'GET'
+        path   = ""
+        params = {}
+        body   = nil
+
+        perform_request(method, path, params, body).body
+      end
+    end
+  end
+end

data/lib/elasticsearch/api/actions/mget.rb

@@ -0,0 +1,64 @@
+module Elasticsearch
+  module API
+    module Actions
+
+      # Return multiple documents from one or more indices in a single request.
+      #
+      # Pass the request definition in the `:body` argument, either as an Array of `docs` specifications,
+      # or `ids`, when the `:index` and document `:type` are specified.
+      #
+      # @example Get multiple documents fully specified in the `docs` definition
+      #
+      #     client.mget body: {
+      #       docs: [
+      #         { _index: 'myindex', _type: 'mytype', _id: '1' },
+      #         { _index: 'myindex', _type: 'mytype', _id: '2' },
+      #         { _index: 'myindex', _type: 'mytype', _id: '3' }
+      #       ]
+      #     }
+      #
+      # @example Get multiple documents specified by `ids` while passing `:index` and `:type`
+      #
+      #     client.mget index: 'myindex', type: 'mytype', body: { ids: ['1', '2', '3'] }
+      #
+      # @example Get only specific fields from documents
+      #
+      #     client.mget index: 'myindex', type: 'mytype', body: { ids: ['1', '2', '3'] }, fields: ['title']
+      #
+      # @option arguments [String] :index The name of the index
+      # @option arguments [String] :type The type of the document
+      # @option arguments [Hash] :body Document identifiers; can be either `docs` (containing full document information)
+      #                                or `ids` (when index and type is provided in the URL (*Required*)
+      # @option arguments [List] :fields A comma-separated list of fields to return in the response
+      # @option arguments [String] :parent The ID of the parent document
+      # @option arguments [String] :preference Specify the node or shard the operation should be performed on
+      #                                        (default: random)
+      # @option arguments [Boolean] :realtime Specify whether to perform the operation in realtime or search mode
+      # @option arguments [Boolean] :refresh Refresh the shard containing the document before performing the operation
+      # @option arguments [String] :routing Specific routing value
+      #
+      # @see http://elasticsearch.org/guide/reference/api/multi-get/
+      #
+      def mget(arguments={})
+        raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
+        method = 'GET'
+        path   = Utils.__pathify( arguments[:index], arguments[:type], '_mget' )
+        params = arguments.select do |k,v|
+          [ :fields,
+            :parent,
+            :preference,
+            :realtime,
+            :refresh,
+            :routing ].include?(k)
+        end
+        # Normalize Ruby 1.8 and Ruby 1.9 Hash#select behaviour
+        params = Hash[params] unless params.is_a?(Hash)
+        body   = arguments[:body]
+
+        params[:fields] = Utils.__listify(params[:fields]) if params[:fields]
+
+        perform_request(method, path, params, body).body
+      end
+    end
+  end
+end

data/lib/elasticsearch/api/actions/mlt.rb

@@ -0,0 +1,86 @@
+module Elasticsearch
+  module API
+    module Actions
+
+      # Return documents similar to the specified one.
+      #
+      # Performs a `more_like_this` query with the specified document as the input.
+      #
+      # @example Search for similar documents using the `title` property of document `myindex/mytype/1`
+      #
+      #     client.mlt index: 'myindex', type: 'mytype', id: '1', mlt_fields: 'title'
+      #
+      # @option arguments [String] :id The document ID (*Required*)
+      # @option arguments [String] :index The name of the index (*Required*)
+      # @option arguments [String] :type The type of the document (use `_all` to fetch
+      #                                  the first document matching the ID across all types) (*Required*)
+      # @option arguments [Hash] :body A specific search request definition
+      # @option arguments [Number] :boost_terms The boost factor
+      # @option arguments [Number] :max_doc_freq The word occurrence frequency as count: words with higher occurrence
+      #                                          in the corpus will be ignored
+      # @option arguments [Number] :max_query_terms The maximum query terms to be included in the generated query
+      # @option arguments [Number] :max_word_len The minimum length of the word: longer words will be ignored
+      # @option arguments [Number] :min_doc_freq The word occurrence frequency as count: words with lower occurrence
+      #                                          in the corpus will be ignored
+      # @option arguments [Number] :min_term_freq The term frequency as percent: terms with lower occurence
+      #                                           in the source document will be ignored
+      # @option arguments [Number] :min_word_len The minimum length of the word: shorter words will be ignored
+      # @option arguments [List] :mlt_fields Specific fields to perform the query against
+      # @option arguments [Number] :percent_terms_to_match How many terms have to match in order to consider
+      #                                                    the document a match (default: 0.3)
+      # @option arguments [String] :routing Specific routing value
+      # @option arguments [Number] :search_from The offset from which to return results
+      # @option arguments [List] :search_indices A comma-separated list of indices to perform the query against
+      #                                          (default: the index containing the document)
+      # @option arguments [String] :search_query_hint The search query hint
+      # @option arguments [String] :search_scroll A scroll search request definition
+      # @option arguments [Number] :search_size The number of documents to return (default: 10)
+      # @option arguments [String] :search_source A specific search request definition (instead of using the request body)
+      # @option arguments [String] :search_type Specific search type (eg. `dfs_then_fetch`, `count`, etc)
+      # @option arguments [List] :search_types A comma-separated list of types to perform the query against
+      #                                        (default: the same type as the document)
+      # @option arguments [List] :stop_words A list of stop words to be ignored
+      #
+      # @see http://elasticsearch.org/guide/reference/api/more-like-this/
+      #
+      def mlt(arguments={})
+        raise ArgumentError, "Required argument 'index' missing" unless arguments[:index]
+        raise ArgumentError, "Required argument 'type' missing"  unless arguments[:type]
+        raise ArgumentError, "Required argument 'id' missing"    unless arguments[:id]
+        method = 'GET'
+        path   = Utils.__pathify( arguments[:index], arguments[:type], arguments[:id], '_mlt' )
+        params = arguments.select do |k,v|
+          [ :boost_terms,
+            :max_doc_freq,
+            :max_query_terms,
+            :max_word_len,
+            :min_doc_freq,
+            :min_term_freq,
+            :min_word_len,
+            :mlt_fields,
+            :percent_terms_to_match,
+            :routing,
+            :search_from,
+            :search_indices,
+            :search_query_hint,
+            :search_scroll,
+            :search_size,
+            :search_source,
+            :search_type,
+            :search_types,
+            :stop_words ].include?(k)
+        end
+        # Normalize Ruby 1.8 and Ruby 1.9 Hash#select behaviour
+        params = Hash[params] unless params.is_a?(Hash)
+
+        [:mlt_fields, :search_indices, :search_types, :stop_words].each do |name|
+          params[name] = Utils.__listify(params[name]) if params[name]
+        end
+
+        body   = arguments[:body]
+
+        perform_request(method, path, params, body).body
+      end
+    end
+  end
+end

data/lib/elasticsearch/api/actions/msearch.rb

@@ -0,0 +1,75 @@
+module Elasticsearch
+  module API
+    module Actions
+
+      # Perform multiple search operations in a single request.
+      #
+      # Pass the search definitions in the `:body` argument
+      #
+      # @example Perform multiple different searches as `:search`
+      #
+      #     client.msearch \
+      #       body: [
+      #         { search: { query: { match_all: {} } } },
+      #         { index: 'myindex', type: 'mytype', search: { query: { query_string: { query: '"Test 1"' } } } },
+      #         { search_type: 'count', search: { facets: { published: { terms: { field: 'published' } } } } }
+      #       ]
+      #
+      # @example Perform multiple different searches as an array of meta/data pairs
+      #
+      #     client.msearch \
+      #       body: [
+      #         { query: { match_all: {} } },
+      #         { index: 'myindex', type: 'mytype' },
+      #         { query: { query_string: { query: '"Test 1"' } } }
+      #         { search_type: 'count' }
+      #         { facets: { published: { terms: { field: 'published' } } } }
+      #       ]
+      #
+      # @option arguments [List] :index A comma-separated list of index names to use as default
+      # @option arguments [List] :type A comma-separated list of document types to use as default
+      # @option arguments [Array<Hash>] :body An array of request definitions, each definition is a Hash;
+      #                                       pass the search definition as a `:search` argument
+      # @option arguments [String] :search_type Search operation type (options: query_then_fetch, query_and_fetch,
+      #                                         dfs_query_then_fetch, dfs_query_and_fetch, count, scan)
+      #
+      # @see http://www.elasticsearch.org/guide/reference/api/multi-search/
+      #
+      def msearch(arguments={})
+        raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
+        method = 'GET'
+        path   = Utils.__pathify( Utils.__listify(arguments[:index]), Utils.__listify(arguments[:type]), '_msearch' )
+        params = arguments.select do |k,v|
+          [ :search_type ].include?(k)
+        end
+        # Normalize Ruby 1.8 and Ruby 1.9 Hash#select behaviour
+        params = Hash[params] unless params.is_a?(Hash)
+        body   = arguments[:body]
+
+        case
+        when body.is_a?(Array) && body.any? { |d| d.has_key? :search }
+          payload = body.
+            inject([]) do |sum, item|
+              meta = item
+              data = meta.delete(:search)
+
+              sum << meta
+              sum << data
+              sum
+            end.
+            map { |item| MultiJson.dump(item) }
+          payload << "" unless payload.empty?
+          payload = payload.join("\n")
+        when body.is_a?(Array)
+          payload = body.map { |d| d.is_a?(String) ? d : MultiJson.dump(d) }
+          payload << "" unless payload.empty?
+          payload = payload.join("\n")
+        else
+          payload = body
+        end
+
+        perform_request(method, path, params, payload).body
+      end
+    end
+  end
+end

data/lib/elasticsearch/api/actions/percolate.rb

@@ -0,0 +1,57 @@
+module Elasticsearch
+  module API
+    module Actions
+
+      # Return names of queries matching the passed document.
+      #
+      # Percolator allows you to register queries and then evaluate a document against them:
+      # the IDs of matching queries are returned in the response.
+      #
+      # @example Register queries named "alert-1" and "alert-2" for the "myindex" index
+      #
+      #     client.index index: '_percolator',
+      #                  type: 'myindex',
+      #                  id: 'alert-1',
+      #                  body: { query: { query_string: { query: 'foo' } } }
+      #
+      #     client.index index: '_percolator',
+      #                  type: 'myindex',
+      #                  id: 'alert-2',
+      #                  body: { query: { query_string: { query: 'bar' } } }
+      #
+      # @example Evaluate a document against the queries
+      #
+      #     client.percolate index: 'myindex', body: { doc: { title: "Foo" } }
+      #     # => {"ok":true,"matches":["alert-1"]}
+      #
+      #     client.percolate index: 'myindex', body: { doc: { title: "Foo Bar" } }
+      #     # => {"ok":true,"matches":["alert-1","alert-2"]}
+      #
+      # @option arguments [String] :index The name of the index with a registered percolator query (*Required*)
+      # @option arguments [String] :type The document type
+      # @option arguments [Hash] :body The document (`doc`) to percolate against registered queries;
+      #                                optionally also a `query` to limit the percolation to specific registered queries
+      # @option arguments [Boolean] :prefer_local With `true`, specify that a local shard should be used if available,
+      #                                           with `false`, use a random shard (default: true)
+      #
+      # @see http://elasticsearch.org/guide/reference/api/percolate/
+      #
+      def percolate(arguments={})
+        raise ArgumentError, "Required argument 'index' missing" unless arguments[:index]
+        raise ArgumentError, "Required argument 'body' missing"  unless arguments[:body]
+        arguments[:type] ||= 'document'
+
+        method = 'GET'
+        path   = "#{arguments[:index]}/#{arguments[:type]}/_percolate"
+        params = arguments.select do |k,v|
+          [ :prefer_local ].include?(k)
+        end
+        # Normalize Ruby 1.8 and Ruby 1.9 Hash#select behaviour
+        params = Hash[params] unless params.is_a?(Hash)
+        body   = arguments[:body]
+
+        perform_request(method, path, params, body).body
+      end
+    end
+  end
+end

data/lib/elasticsearch/api/actions/ping.rb

@@ -0,0 +1,29 @@
+module Elasticsearch
+  module API
+    module Actions
+
+      # Returns true if the cluster returns a sucessfull HTTP response, false otherwise.
+      #
+      # @example
+      #
+      #     client.ping
+      #
+      # @see http://elasticsearch.org/guide/
+      #
+      def ping(arguments={})
+        method = 'HEAD'
+        path   = ""
+        params = {}
+        body   = nil
+
+        perform_request(method, path, params, body).status == 200 ? true : false
+        rescue Exception => e
+          if e.class.to_s =~ /NotFound/ || e.message =~ /Not\s*Found|404/i
+            false
+          else
+            raise e
+          end
+      end
+    end
+  end
+end

data/lib/elasticsearch/api/actions/scroll.rb

@@ -0,0 +1,44 @@
+module Elasticsearch
+  module API
+    module Actions
+
+      # Efficiently iterate over a large result set.
+      #
+      # When using `from` and `size` to return a large result sets, performance drops as you "paginate" in the set,
+      # and you can't guarantee the consistency when the index is being updated at the same time.
+      #
+      # "Scrolling" the results is frequently used with the `scan` search type.
+      #
+      # @example Scroll results
+      #
+      #     result = client.search index: 'scrollindex',
+      #                            scroll: '5m',
+      #                            body: { query: { match: { title: 'test' } }, sort: '_id' }
+      #
+      #     client.scroll scroll: '5m', scroll_id: result['_scroll_id']
+      #
+      # @option arguments [String] :scroll_id The scroll ID
+      # @option arguments [Hash] :body The scroll ID if not passed by URL or query parameter.
+      # @option arguments [Duration] :scroll Specify how long a consistent view of the index
+      #                                      should be maintained for scrolled search
+      # @option arguments [String] :scroll_id The scroll ID for scrolled search
+      #
+      # @see http://www.elasticsearch.org/guide/reference/api/search/scroll/
+      # @see http://www.elasticsearch.org/guide/reference/api/search/search-type/
+      #
+      def scroll(arguments={})
+        method = 'GET'
+        path   = "_search/scroll"
+        params = arguments.select do |k,v|
+          [ :scroll,
+            :scroll_id ].include?(k)
+        end
+        # Normalize Ruby 1.8 and Ruby 1.9 Hash#select behaviour
+        params = Hash[params] unless params.is_a?(Hash)
+        body   = arguments[:body]
+
+        perform_request(method, path, params, body).body
+      end
+    end
+  end
+end