clj-elasticsearch.client — clj-elasticsearch 0.4.0-RC1

*client* clj

analyze-request clj

(analyze-request {:keys [analyzer async? field format index listener
                         operation-threaded? prefer-local? token-filters
                         tokenizer]
                  :as params})

(analyze-request client params)

Generated from Class org.elasticsearch.action.admin.indices.analyze.AnalyzeRequest Params keys: :index => (required) String :analyzer => String :async? => if set to true, the call returns a Future instead of blocking :field => String :format => one of :clj, :json or :java :listener => takes a listener object and makes the call async :operation-threaded? => boolean :prefer-local? => boolean :token-filters => seq of Strings :tokenizer => String

apply-mappers clj

(apply-mappers fns vs)

atomic-update-from-source clj

(atomic-update-from-source f opts)

(atomic-update-from-source f client opts)

atomically updates a document with an optimistic concurrency control policy. The provided function will receive the _source field of the doc as param, or nil if the doc id does not exist. If the function returns a map, it will become the new value, else nothing will happen. Any additional values you want to pass to the requests have to be set into the opts param.

base-wrapped-params-doc clj

build-document clj

(build-document doc)

returns a string representation of a document suitable for indexing

class-for-name clj

(class-for-name class-name)

clear-index-cache clj

(clear-index-cache {:keys [async? bloom-cache? field-data-cache? fields
                           filter-cache? format id-cache? ignore-indices indices
                           listener operation-threading]
                    :as params})

(clear-index-cache client params)

Generated from Class org.elasticsearch.action.admin.indices.cache.clear.ClearIndicesCacheRequest Params keys: :indices => (required) seq of Strings :async? => if set to true, the call returns a Future instead of blocking :bloom-cache? => boolean :field-data-cache? => boolean :fields => seq of Strings :filter-cache? => boolean :format => one of :clj, :json or :java :id-cache? => boolean :ignore-indices => one of :default, :none or :missing :listener => takes a listener object and makes the call async :operation-threading => one of :no-threads, :single-thread or :thread-per-shard Response fields expected #{:shard-failures :headers :total-shards :successful-shards :failed-shards}

client-types clj

Closable clj protocol

close clj

(close this)

closes this Elasticsearch client and any underlying infrastructure

close-index clj

(close-index {:keys [async? format index listener master-node-timeout timeout]
              :as params})

(close-index client params)

Generated from Class org.elasticsearch.action.admin.indices.close.CloseIndexRequest Params keys: :index => (required) String :async? => if set to true, the call returns a Future instead of blocking :format => one of :clj, :json or :java :listener => takes a listener object and makes the call async :master-node-timeout => String time spec (ex: "5s") :timeout => String time spec (ex: "5s")

cluster-health clj

(cluster-health {:keys [async? format indices listener master-node-timeout
                        timeout wait-for-active-shards wait-for-nodes
                        wait-for-relocating-shards wait-for-status]
                 :as params})

(cluster-health client params)

Generated from Class org.elasticsearch.action.admin.cluster.health.ClusterHealthRequest Params keys: :indices => (required) seq of Strings :async? => if set to true, the call returns a Future instead of blocking :format => one of :clj, :json or :java :listener => takes a listener object and makes the call async :master-node-timeout => String time spec (ex: "5s") :timeout => String time spec (ex: "5s") :wait-for-active-shards => int :wait-for-nodes => String :wait-for-relocating-shards => int :wait-for-status => one of :green, :yellow or :red Response fields expected #{:cluster-name :active-shards :validation-failures :initializing-shards :timed-out? :active-primary-shards :headers :number-of-nodes :status :indices :all-validation-failures :unassigned-shards :number-of-data-nodes :relocating-shards}

cluster-state clj

(cluster-state {:keys [async? filter-blocks? filter-meta-data? filter-nodes?
                       filter-routing-table? filtered-index-templates
                       filtered-indices format listener local?
                       master-node-timeout]
                :as params})

(cluster-state client params)

Generated from Class org.elasticsearch.action.admin.cluster.state.ClusterStateRequest Params keys: :async? => if set to true, the call returns a Future instead of blocking :filter-blocks? => boolean :filter-meta-data? => boolean :filter-nodes? => boolean :filter-routing-table? => boolean :filtered-index-templates => seq of Strings :filtered-indices => seq of Strings :format => one of :clj, :json or :java :listener => takes a listener object and makes the call async :local? => boolean :master-node-timeout => String time spec (ex: "5s") Response fields expected #{:cluster-name :state :headers}

collapse-tree clj

(collapse-tree m)

compatible-decode-smile clj

ComposableListener clj protocol

compose clj

(compose this listener)

composes with the given listener, returning a new listener

getFailureHandler clj

(getFailureHandler this)

getFormat clj

(getFormat this)

getResponseHandler clj

(getResponseHandler this)

convert clj

(convert response)

(convert response format)

convert* clj

count-docs clj

(count-docs {:keys [async? format ignore-indices indices listener min-score
                    operation-threading query query-hint routing types]
             :as params})

(count-docs client params)

Generated from Class org.elasticsearch.action.count.CountRequest Params keys: :indices => (required) seq of Strings :async? => if set to true, the call returns a Future instead of blocking :format => one of :clj, :json or :java :ignore-indices => one of :default, :none or :missing :listener => takes a listener object and makes the call async :min-score => float :operation-threading => one of :no-threads, :single-thread or :thread-per-shard :query => HashMap or JSON String or SMILE bytes-array :query-hint => String :routing => String or seq of Strings :types => seq of Strings Response fields expected #{:shard-failures :headers :total-shards :successful-shards :failed-shards :count}

create-index clj

(create-index {:keys [async? cause custom format index listener
                      master-node-timeout source timeout tings]
               :as params})

(create-index client params)

Generated from Class org.elasticsearch.action.admin.indices.create.CreateIndexRequest Params keys: :index => (required) String :async? => if set to true, the call returns a Future instead of blocking :cause => String :custom => IndexMetaData$Custom :format => one of :clj, :json or :java :listener => takes a listener object and makes the call async :master-node-timeout => String time spec (ex: "5s") :source => HashMap or JSON String or SMILE bytes-array :timeout => String time spec (ex: "5s") :tings => HashMap of Settings Response fields expected #{:acknowledged? :headers}

def-requests clj macro

(def-requests client-type & request-defs)

delete-by-query clj

(delete-by-query {:keys [async? consistency-level format indices listener query
                         replication-type routing timeout types]
                  :as params})

(delete-by-query client params)

Generated from Class org.elasticsearch.action.deletebyquery.DeleteByQueryRequest Params keys: :query => (required) HashMap or JSON String or SMILE bytes-array :async? => if set to true, the call returns a Future instead of blocking :consistency-level => one of :default, :one, :quorum or :all :format => one of :clj, :json or :java :indices => seq of Strings :listener => takes a listener object and makes the call async :replication-type => one of :sync, :async or :default :routing => String or seq of Strings :timeout => String time spec (ex: "5s") :types => seq of Strings Response fields expected #{:headers :indices}

delete-doc clj

(delete-doc {:keys [async? consistency-level format id index listener
                    operation-threaded? parent refresh? replication-type routing
                    timeout type version version-type]
             :as params})

(delete-doc client params)

Generated from Class org.elasticsearch.action.delete.DeleteRequest Params keys: :id => (required) String :index => (required) String :type => (required) String :async? => if set to true, the call returns a Future instead of blocking :consistency-level => one of :default, :one, :quorum or :all :format => one of :clj, :json or :java :listener => takes a listener object and makes the call async :operation-threaded? => boolean :parent => String :refresh? => boolean :replication-type => one of :sync, :async or :default :routing => String :timeout => String time spec (ex: "5s") :version => long :version-type => one of :internal or :external Response fields expected #{:index :not-found? :type :headers :id :version}

delete-index clj

(delete-index {:keys [async? format indices listener master-node-timeout
                      timeout]
               :as params})

(delete-index client params)

Generated from Class org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest Params keys: :indices => (required) seq of Strings :async? => if set to true, the call returns a Future instead of blocking :format => one of :clj, :json or :java :listener => takes a listener object and makes the call async :master-node-timeout => String time spec (ex: "5s") :timeout => String time spec (ex: "5s") Response fields expected #{:acknowledged? :headers}

delete-mapping clj

(delete-mapping {:keys [async? format indices listener master-node-timeout type]
                 :as params})

(delete-mapping client params)

Generated from Class org.elasticsearch.action.admin.indices.mapping.delete.DeleteMappingRequest Params keys: :indices => (required) seq of Strings :async? => if set to true, the call returns a Future instead of blocking :format => one of :clj, :json or :java :listener => takes a listener object and makes the call async :master-node-timeout => String time spec (ex: "5s") :type => String Response fields expected #{:headers}

delete-template clj

(delete-template {:keys [async? format listener master-node-timeout timeout]
                  :as params})

(delete-template client params)

Generated from Class org.elasticsearch.action.admin.indices.template.delete.DeleteIndexTemplateRequest Params keys: :async? => if set to true, the call returns a Future instead of blocking :format => one of :clj, :json or :java :listener => takes a listener object and makes the call async :master-node-timeout => String time spec (ex: "5s") :timeout => String time spec (ex: "5s") Response fields expected #{:acknowledged? :headers}

enum->kw clj

(enum->kw enum)

exists-index clj

(exists-index {:keys [async? format listener master-node-timeout] :as params})

(exists-index client params)

Generated from Class org.elasticsearch.action.admin.indices.exists.indices.IndicesExistsRequest Params keys: :async? => if set to true, the call returns a Future instead of blocking :format => one of :clj, :json or :java :listener => takes a listener object and makes the call async :master-node-timeout => String time spec (ex: "5s") Response fields expected #{:headers :exists?}

find-terminals clj

(find-terminals spec)

flush-index clj

(flush-index {:keys [async? force? format full? ignore-indices indices listener
                     operation-threading refresh?]
              :as params})

(flush-index client params)

Generated from Class org.elasticsearch.action.admin.indices.flush.FlushRequest Params keys: :indices => (required) seq of Strings :async? => if set to true, the call returns a Future instead of blocking :force? => boolean :format => one of :clj, :json or :java :full? => boolean :ignore-indices => one of :default, :none or :missing :listener => takes a listener object and makes the call async :operation-threading => one of :no-threads, :single-thread or :thread-per-shard :refresh? => boolean Response fields expected #{:shard-failures :headers :total-shards :successful-shards :failed-shards}

FromSource clj protocol

convert-source clj

(convert-source this)

convert source to bytes

gateway-snapshot clj

(gateway-snapshot {:keys [async? format ignore-indices indices listener
                          operation-threading]
                   :as params})

(gateway-snapshot client params)

Generated from Class org.elasticsearch.action.admin.indices.gateway.snapshot.GatewaySnapshotRequest Params keys: :indices => (required) seq of Strings :async? => if set to true, the call returns a Future instead of blocking :format => one of :clj, :json or :java :ignore-indices => one of :default, :none or :missing :listener => takes a listener object and makes the call async :operation-threading => one of :no-threads, :single-thread or :thread-per-shard Response fields expected #{:shard-failures :headers :total-shards :successful-shards :failed-shards}

get-doc clj

(get-doc {:keys [async? fields format id index listener operation-threaded?
                 parent preference realtime? refresh? routing type]
          :as params})

(get-doc client params)

Generated from Class org.elasticsearch.action.get.GetRequest Params keys: :id => (required) String :index => (required) String :async? => if set to true, the call returns a Future instead of blocking :fields => seq of Strings :format => one of :clj, :json or :java :listener => takes a listener object and makes the call async :operation-threaded? => boolean :parent => String :preference => String :realtime? => Boolean :refresh? => boolean :routing => String :type => String

get-empty-params clj

(get-empty-params class-name)

get-mapping clj

(get-mapping params)

(get-mapping client params)

Gets mappings from cluster. Wrapper over cluster-state Params keys: :async? => if set to true, the call returns a Future instead of blocking :indices => seq of Strings :listener => takes a listener object and makes the call async :types => seq of Strings

index-doc clj

(index-doc {:keys [async? consistency-level content-type create? format id index
                   listener op-type operation-threaded? parent percolate
                   refresh? replication-type routing source timeout timestamp
                   ttl type version version-type]
            :as params})

(index-doc client params)

Generated from Class org.elasticsearch.action.index.IndexRequest Params keys: :index => (required) String :source => (required) HashMap or JSON String or SMILE bytes-array :type => (required) String :async? => if set to true, the call returns a Future instead of blocking :consistency-level => one of :default, :one, :quorum or :all :content-type => one of :json, :smile or :yaml :create? => boolean :format => one of :clj, :json or :java :id => String :listener => takes a listener object and makes the call async :op-type => one of :index or :create :operation-threaded? => boolean :parent => String :percolate => String :refresh? => boolean :replication-type => one of :sync, :async or :default :routing => String :timeout => String time spec (ex: "5s") :timestamp => String :ttl => Long :version => long :version-type => one of :internal or :external Response fields expected #{:index :type :matches :headers :id :version}

index-segments clj

(index-segments {:keys [async? format ignore-indices indices listener
                        operation-threading]
                 :as params})

(index-segments client params)

Generated from Class org.elasticsearch.action.admin.indices.segments.IndicesSegmentsRequest Params keys: :async? => if set to true, the call returns a Future instead of blocking :format => one of :clj, :json or :java :ignore-indices => one of :default, :none or :missing :indices => seq of Strings :listener => takes a listener object and makes the call async :operation-threading => one of :no-threads, :single-thread or :thread-per-shard

index-stats clj

(index-stats {:keys [async? docs? flush? format get? groups ignore-indices
                     indexing? indices listener merge? operation-threading
                     refresh? search? store? types warmer?]
              :as params})

(index-stats client params)

Generated from Class org.elasticsearch.action.admin.indices.stats.IndicesStatsRequest Params keys: :async? => if set to true, the call returns a Future instead of blocking :docs? => boolean :flush? => boolean :format => one of :clj, :json or :java :get? => boolean :groups => seq of Strings :ignore-indices => one of :default, :none or :missing :indexing? => boolean :indices => seq of Strings :listener => takes a listener object and makes the call async :merge? => boolean :operation-threading => one of :no-threads, :single-thread or :thread-per-shard :refresh? => boolean :search? => boolean :store? => boolean :types => seq of Strings :warmer? => boolean

index-status clj

(index-status {:keys [async? format ignore-indices indices listener
                      operation-threading recovery? snapshot?]
               :as params})

(index-status client params)

Generated from Class org.elasticsearch.action.admin.indices.status.IndicesStatusRequest Params keys: :async? => if set to true, the call returns a Future instead of blocking :format => one of :clj, :json or :java :ignore-indices => one of :default, :none or :missing :indices => seq of Strings :listener => takes a listener object and makes the call async :operation-threading => one of :no-threads, :single-thread or :thread-per-shard :recovery? => boolean :snapshot? => boolean

kw->enum clj

(kw->enum kw)

make-client clj

(make-client type spec)

creates a client of given type (:node or :transport) and spec

make-constructor clj

(make-constructor klass names)

make-enum-tables clj

make-enum-tables* clj

(make-enum-tables* t)

make-es-future clj

(make-es-future action-future
                {:keys [format async-callback]
                 :or {async-callback identity format :clj}})

make-listener clj

(make-listener {:keys [on-failure on-response format]
                :or {format :clj
                     on-failure (fn [e]
                                    (binding [*out* *err*]
                                             (println "Error in listener")
                                             (cst/print-cause-trace e)))}})

makes a listener suitable as a callback for requests

make-node clj

(make-node
  {:keys [local-mode client-mode load-config cluster-name settings hosts]
   :or {client-mode true load-config false local-mode false settings {}}
   :as args})

makes a new native elasticsearch node

make-requester clj

(make-requester client-type request-class-name cst-args req-args)

make-requester-wrapper clj

(make-requester-wrapper requester
                        &
                        {:keys [on-params on-response argslist fn-doc]
                         :or {on-params identity
                              on-response identity
                              argslist [[(quote client) (quote params)]
                                        [(quote params)]]
                              fn-doc "Generated based on another requester."}})

make-transport-client clj

(make-transport-client {:keys [load-config cluster-name settings hosts sniff]
                        :or {client-mode true
                             load-config false
                             local-mode false
                             settings {}
                             sniff true}
                        :as args})

creates a transport client

make-wrapped-doc clj

(make-wrapped-doc msg specs)

more-like-this clj

(more-like-this {:keys [async? boost-terms fields format id listener
                        listener-threaded? max-doc-freq max-query-terms
                        max-word-len min-doc-freq min-term-freq min-word-len
                        percent-terms-to-match search-from search-indices
                        search-query-hint search-scroll search-size
                        search-source search-type search-types stop-words type]
                 :as params})

(more-like-this client params)

Generated from Class org.elasticsearch.action.mlt.MoreLikeThisRequest Params keys: :id => (required) String :type => (required) String :async? => if set to true, the call returns a Future instead of blocking :boost-terms => float :fields => seq of Strings :format => one of :clj, :json or :java :listener => takes a listener object and makes the call async :listener-threaded? => boolean :max-doc-freq => int :max-query-terms => int :max-word-len => int :min-doc-freq => int :min-term-freq => int :min-word-len => int :percent-terms-to-match => float :search-from => int :search-indices => seq of Strings :search-query-hint => String :search-scroll => String time spec (ex: "5s") :search-size => int :search-source => HashMap or JSON String or SMILE bytes-array :search-type => one of :dfs-query-then-fetch, :query-then-fetch, :dfs-query-and-fetch, :query-and-fetch, :scan or :count :search-types => seq of Strings :stop-words => seq of Strings

node-info clj

(node-info {:keys [async? format http? jvm? listener network? nodes-ids os?
                   process? thread-pool? timeout tings? transport?]
            :as params})

(node-info client params)

Generated from Class org.elasticsearch.action.admin.cluster.node.info.NodesInfoRequest Params keys: :async? => if set to true, the call returns a Future instead of blocking :format => one of :clj, :json or :java :http? => boolean :jvm? => boolean :listener => takes a listener object and makes the call async :network? => boolean :nodes-ids => seq of Strings :os? => boolean :process? => boolean :thread-pool? => boolean :timeout => String time spec (ex: "5s") :tings? => boolean :transport? => boolean Response fields expected #{:cluster-name :nodes-map :headers :nodes}

node-restart clj

(node-restart {:keys [async? delay format listener nodes-ids timeout]
               :as params})

(node-restart client params)

Generated from Class org.elasticsearch.action.admin.cluster.node.restart.NodesRestartRequest Params keys: :nodes-ids => (required) seq of Strings :async? => if set to true, the call returns a Future instead of blocking :delay => String time spec (ex: "5s") :format => one of :clj, :json or :java :listener => takes a listener object and makes the call async :timeout => String time spec (ex: "5s") Response fields expected #{:cluster-name :nodes-map :headers :nodes}

node-shutdown clj

(node-shutdown {:keys [async? delay exit? format listener master-node-timeout
                       nodes-ids]
                :as params})

(node-shutdown client params)

Generated from Class org.elasticsearch.action.admin.cluster.node.shutdown.NodesShutdownRequest Params keys: :nodes-ids => (required) seq of Strings :async? => if set to true, the call returns a Future instead of blocking :delay => String time spec (ex: "5s") :exit? => boolean :format => one of :clj, :json or :java :listener => takes a listener object and makes the call async :master-node-timeout => String time spec (ex: "5s") Response fields expected #{:cluster-name :headers :nodes}

nodes-stats clj

(nodes-stats {:keys [async? format fs? http? indices? jvm? listener network?
                     nodes-ids os? process? thread-pool? timeout transport?]
              :as params})

(nodes-stats client params)

Generated from Class org.elasticsearch.action.admin.cluster.node.stats.NodesStatsRequest Params keys: :nodes-ids => (required) seq of Strings :async? => if set to true, the call returns a Future instead of blocking :format => one of :clj, :json or :java :fs? => boolean :http? => boolean :indices? => boolean :jvm? => boolean :listener => takes a listener object and makes the call async :network? => boolean :os? => boolean :process? => boolean :thread-pool? => boolean :timeout => String time spec (ex: "5s") :transport? => boolean Response fields expected #{:cluster-name :nodes-map :headers :nodes}

optimize-index clj

(optimize-index {:keys [async? flush? format ignore-indices indices listener
                        max-num-segments only-expunge-deletes?
                        operation-threading refresh? wait-for-merge?]
                 :as params})

(optimize-index client params)

Generated from Class org.elasticsearch.action.admin.indices.optimize.OptimizeRequest Params keys: :async? => if set to true, the call returns a Future instead of blocking :flush? => boolean :format => one of :clj, :json or :java :ignore-indices => one of :default, :none or :missing :indices => seq of Strings :listener => takes a listener object and makes the call async :max-num-segments => int :only-expunge-deletes? => boolean :operation-threading => one of :no-threads, :single-thread or :thread-per-shard :refresh? => boolean :wait-for-merge? => boolean Response fields expected #{:shard-failures :headers :total-shards :successful-shards :failed-shards}

PClient clj protocol

getClient clj

(getClient this)

returns a Elasticsearch Client instance

percolate clj

(percolate {:keys [async? format index listener operation-threaded?
                   prefer-local? source type]
            :as params})

(percolate client params)

Generated from Class org.elasticsearch.action.percolate.PercolateRequest Params keys: :index => (required) String :source => (required) HashMap or JSON String or SMILE bytes-array :type => (required) String :async? => if set to true, the call returns a Future instead of blocking :format => one of :clj, :json or :java :listener => takes a listener object and makes the call async :operation-threaded? => boolean :prefer-local? => boolean Response fields expected #{:headers}

put-mapping clj

(put-mapping {:keys [async? format ignore-conflicts? indices listener
                     master-node-timeout source timeout type]
              :as params})

(put-mapping client params)

Generated from Class org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequest Params keys: :indices => (required) seq of Strings :async? => if set to true, the call returns a Future instead of blocking :format => one of :clj, :json or :java :ignore-conflicts? => boolean :listener => takes a listener object and makes the call async :master-node-timeout => String time spec (ex: "5s") :source => HashMap or JSON String :timeout => String time spec (ex: "5s") :type => String Response fields expected #{:acknowledged? :headers}

put-template clj

(put-template {:keys [async? cause create? custom format listener
                      master-node-timeout name order source template timeout
                      tings]
               :as params})

(put-template client params)

Generated from Class org.elasticsearch.action.admin.indices.template.put.PutIndexTemplateRequest Params keys: :name => (required) String :async? => if set to true, the call returns a Future instead of blocking :cause => String :create? => boolean :custom => IndexMetaData$Custom :format => one of :clj, :json or :java :listener => takes a listener object and makes the call async :master-node-timeout => String time spec (ex: "5s") :order => int :source => HashMap or JSON String or SMILE bytes-array :template => String :timeout => String time spec (ex: "5s") :tings => HashMap of Settings Response fields expected #{:acknowledged? :headers}

refresh-index clj

(refresh-index {:keys [async? format ignore-indices indices listener
                       operation-threading wait-for-operations?]
                :as params})

(refresh-index client params)

Generated from Class org.elasticsearch.action.admin.indices.refresh.RefreshRequest Params keys: :indices => (required) seq of Strings :async? => if set to true, the call returns a Future instead of blocking :format => one of :clj, :json or :java :ignore-indices => one of :default, :none or :missing :listener => takes a listener object and makes the call async :operation-threading => one of :no-threads, :single-thread or :thread-per-shard :wait-for-operations? => boolean Response fields expected #{:shard-failures :headers :total-shards :successful-shards :failed-shards}

scroll clj

(scroll {:keys [async? format listener listener-threaded? operation-threading
                scroll scroll-id]
         :as params})

(scroll client params)

Generated from Class org.elasticsearch.action.search.SearchScrollRequest Params keys: :scroll-id => (required) String :async? => if set to true, the call returns a Future instead of blocking :format => one of :clj, :json or :java :listener => takes a listener object and makes the call async :listener-threaded? => boolean :operation-threading => one of :no-threads, :single-thread or :thread-per-shard :scroll => String time spec (ex: "5s")

search clj

(search {:keys [async? extra-source format ignore-indices indices listener
                listener-threaded? operation-threading preference query-hint
                routing scroll search-type source types]
         :as params})

(search client params)

Generated from Class org.elasticsearch.action.search.SearchRequest Params keys: :async? => if set to true, the call returns a Future instead of blocking :extra-source => HashMap or JSON String or SMILE bytes-array :format => one of :clj, :json or :java :ignore-indices => one of :default, :none or :missing :indices => seq of Strings :listener => takes a listener object and makes the call async :listener-threaded? => boolean :operation-threading => one of :no-threads, :single-thread or :thread-per-shard :preference => String :query-hint => String :routing => String or seq of Strings :scroll => String time spec (ex: "5s") :search-type => one of :dfs-query-then-fetch, :query-then-fetch, :dfs-query-and-fetch, :query-and-fetch, :scan or :count :source => HashMap or JSON String or SMILE bytes-array :types => seq of Strings

select-vals clj

(select-vals h ks)

str-conv clj

(str-conv _ o _)

translator clj

update-cluster-settings clj

(update-cluster-settings {:keys [async? format listener master-node-timeout
                                 persistent-settings transient-settings]
                          :as params})

(update-cluster-settings client params)

Generated from Class org.elasticsearch.action.admin.cluster.settings.ClusterUpdateSettingsRequest Params keys: :async? => if set to true, the call returns a Future instead of blocking :format => one of :clj, :json or :java :listener => takes a listener object and makes the call async :master-node-timeout => String time spec (ex: "5s") :persistent-settings => HashMap of Settings :transient-settings => HashMap of Settings Response fields expected #{:headers}

update-doc clj

(update-doc {:keys [async? consistency-level doc fields format id index listener
                    parent percolate refresh? replication-type retry-on-conflict
                    routing script script-lang script-params source timeout type
                    upsert]
             :as params})

(update-doc client params)

Generated from Class org.elasticsearch.action.update.UpdateRequest Params keys: :id => (required) String :index => (required) String :script => (required) String :type => (required) String :async? => if set to true, the call returns a Future instead of blocking :consistency-level => one of :default, :one, :quorum or :all :doc => HashMap or JSON String or SMILE bytes-array :fields => seq of Strings :format => one of :clj, :json or :java :listener => takes a listener object and makes the call async :parent => String :percolate => String :refresh? => boolean :replication-type => one of :sync, :async or :default :retry-on-conflict => int :routing => String :script-lang => String :script-params => Map :source => HashMap or JSON String or SMILE bytes-array :timeout => String time spec (ex: "5s") :upsert => HashMap or JSON String or SMILE bytes-array Response fields expected #{:index :get-result :type :matches :headers :result :id :version}

update-index-settings clj

(update-index-settings
  {:keys [async? format indices listener master-node-timeout tings] :as params})

(update-index-settings client params)

Generated from Class org.elasticsearch.action.admin.indices.settings.UpdateSettingsRequest Params keys: :indices => (required) seq of Strings :async? => if set to true, the call returns a Future instead of blocking :format => one of :clj, :json or :java :listener => takes a listener object and makes the call async :master-node-timeout => String time spec (ex: "5s") :tings => HashMap of Settings Response fields expected #{:headers}

update-settings-builder clj

(update-settings-builder settings)

(update-settings-builder builder settings)

creates or updates a settingsBuilder with the given hash-map

with-client clj macro

(with-client client & body)

uses an existing client in the body, does not close it afterward

with-node-client clj macro

(with-node-client server-spec & body)

opens a node client with given spec and executes the body before closing it

with-transport-client clj macro

(with-transport-client server-spec & body)

opens a transport client with given spec and executes the body before closing it