Add missing properties to Count API

The Count service was missing a few properties from the REST API.

Author: olivere

client.go

@@ -22,7 +22,7 @@ import (
 
 const (
 	// Version is the current version of Elastic.
-	Version = "3.0.1"
+	Version = "3.0.2"
 
 	// DefaultUrl is the default endpoint of Elasticsearch on the local machine.
 	// It is used e.g. when initializing a new Client without a specific URL.

count.go

@@ -17,99 +17,259 @@ import (
 // number of documents in an index. Use SearchService with
 // a SearchType of count for counting with queries etc.
 type CountService struct {
-	client  *Client
-	indices []string
-	types   []string
-	query   Query
-	pretty  bool
-}
-
-// CountResult is the result returned from using the Count API
-// (http://www.elasticsearch.org/guide/reference/api/count/)
-type CountResult struct {
-	Count  int64      `json:"count"`
-	Shards shardsInfo `json:"_shards,omitempty"`
+	client                 *Client
+	pretty                 bool
+	index                  []string
+	typ                    []string
+	allowNoIndices         *bool
+	analyzeWildcard        *bool
+	analyzer               string
+	defaultOperator        string
+	df                     string
+	expandWildcards        string
+	ignoreUnavailable      *bool
+	lenient                *bool
+	lowercaseExpandedTerms *bool
+	minScore               interface{}
+	preference             string
+	q                      string
+	query                  Query
+	routing                string
+	bodyJson               interface{}
+	bodyString             string
 }
 
+// NewCountService creates a new CountService.
 func NewCountService(client *Client) *CountService {
-	builder := &CountService{
+	return &CountService{
 		client: client,
 	}
-	return builder
 }
 
-func (s *CountService) Index(indices ...string) *CountService {
-	if s.indices == nil {
-		s.indices = make([]string, 0)
+// Index sets the names of the indices to restrict the results.
+func (s *CountService) Index(index ...string) *CountService {
+	if s.index == nil {
+		s.index = make([]string, 0)
 	}
-	s.indices = append(s.indices, indices...)
+	s.index = append(s.index, index...)
 	return s
 }
 
-func (s *CountService) Type(types ...string) *CountService {
-	if s.types == nil {
-		s.types = make([]string, 0)
+// Type sets the types to use to restrict the results.
+func (s *CountService) Type(typ ...string) *CountService {
+	if s.typ == nil {
+		s.typ = make([]string, 0)
 	}
-	s.types = append(s.types, types...)
+	s.typ = append(s.typ, typ...)
+	return s
+}
+
+// AllowNoIndices indicates whether to ignore if a wildcard indices
+// expression resolves into no concrete indices. (This includes "_all" string
+// or when no indices have been specified).
+func (s *CountService) AllowNoIndices(allowNoIndices bool) *CountService {
+	s.allowNoIndices = &allowNoIndices
+	return s
+}
+
+// AnalyzeWildcard specifies whether wildcard and prefix queries should be
+// analyzed (default: false).
+func (s *CountService) AnalyzeWildcard(analyzeWildcard bool) *CountService {
+	s.analyzeWildcard = &analyzeWildcard
+	return s
+}
+
+// Analyzer specifies the analyzer to use for the query string.
+func (s *CountService) Analyzer(analyzer string) *CountService {
+	s.analyzer = analyzer
+	return s
+}
+
+// DefaultOperator specifies the default operator for query string query (AND or OR).
+func (s *CountService) DefaultOperator(defaultOperator string) *CountService {
+	s.defaultOperator = defaultOperator
+	return s
+}
+
+// Df specifies the field to use as default where no field prefix is given
+// in the query string.
+func (s *CountService) Df(df string) *CountService {
+	s.df = df
+	return s
+}
+
+// ExpandWildcards indicates whether to expand wildcard expression to
+// concrete indices that are open, closed or both.
+func (s *CountService) ExpandWildcards(expandWildcards string) *CountService {
+	s.expandWildcards = expandWildcards
 	return s
 }
 
+// IgnoreUnavailable indicates whether specified concrete indices should be
+// ignored when unavailable (missing or closed).
+func (s *CountService) IgnoreUnavailable(ignoreUnavailable bool) *CountService {
+	s.ignoreUnavailable = &ignoreUnavailable
+	return s
+}
+
+// Lenient specifies whether format-based query failures (such as
+// providing text to a numeric field) should be ignored.
+func (s *CountService) Lenient(lenient bool) *CountService {
+	s.lenient = &lenient
+	return s
+}
+
+// LowercaseExpandedTerms specifies whether query terms should be lowercased.
+func (s *CountService) LowercaseExpandedTerms(lowercaseExpandedTerms bool) *CountService {
+	s.lowercaseExpandedTerms = &lowercaseExpandedTerms
+	return s
+}
+
+// MinScore indicates to include only documents with a specific `_score`
+// value in the result.
+func (s *CountService) MinScore(minScore interface{}) *CountService {
+	s.minScore = minScore
+	return s
+}
+
+// Preference specifies the node or shard the operation should be
+// performed on (default: random).
+func (s *CountService) Preference(preference string) *CountService {
+	s.preference = preference
+	return s
+}
+
+// Q in the Lucene query string syntax. You can also use Query to pass
+// a Query struct.
+func (s *CountService) Q(q string) *CountService {
+	s.q = q
+	return s
+}
+
+// Query specifies the query to pass. You can also pass a query string with Q.
 func (s *CountService) Query(query Query) *CountService {
 	s.query = query
 	return s
 }
 
+// Routing specifies the routing value.
+func (s *CountService) Routing(routing string) *CountService {
+	s.routing = routing
+	return s
+}
+
+// Pretty indicates that the JSON response be indented and human readable.
 func (s *CountService) Pretty(pretty bool) *CountService {
 	s.pretty = pretty
 	return s
 }
 
-func (s *CountService) Do() (int64, error) {
-	var err error
+// BodyJson specifies the query to restrict the results specified with the
+// Query DSL (optional). The interface{} will be serialized to a JSON document,
+// so use a map[string]interface{}.
+func (s *CountService) BodyJson(body interface{}) *CountService {
+	s.bodyJson = body
+	return s
+}
 
-	// Build url
-	path := "/"
+// Body specifies a query to restrict the results specified with
+// the Query DSL (optional).
+func (s *CountService) BodyString(body string) *CountService {
+	s.bodyString = body
+	return s
+}
 
-	// Indices part
-	indexPart := make([]string, 0)
-	for _, index := range s.indices {
-		index, err = uritemplates.Expand("{index}", map[string]string{
-			"index": index,
+// buildURL builds the URL for the operation.
+func (s *CountService) buildURL() (string, url.Values, error) {
+	var err error
+	var path string
+
+	if len(s.index) > 0 && len(s.typ) > 0 {
+		path, err = uritemplates.Expand("/{index}/{type}/_count", map[string]string{
+			"index": strings.Join(s.index, ","),
+			"type":  strings.Join(s.typ, ","),
 		})
-		if err != nil {
-			return 0, err
-		}
-		indexPart = append(indexPart, index)
+	} else if len(s.index) > 0 {
+		path, err = uritemplates.Expand("/{index}/_count", map[string]string{
+			"index": strings.Join(s.index, ","),
+		})
+	} else if len(s.typ) > 0 {
+		path, err = uritemplates.Expand("/_all/{type}/_count", map[string]string{
+			"type": strings.Join(s.typ, ","),
+		})
+	} else {
+		path = "/_all/_count"
 	}
-	if len(indexPart) > 0 {
-		path += strings.Join(indexPart, ",")
+	if err != nil {
+		return "", url.Values{}, err
 	}
 
-	// Types part
-	typesPart := make([]string, 0)
-	for _, typ := range s.types {
-		typ, err = uritemplates.Expand("{type}", map[string]string{
-			"type": typ,
-		})
-		if err != nil {
-			return 0, err
-		}
-		typesPart = append(typesPart, typ)
+	// Add query string parameters
+	params := url.Values{}
+	if s.pretty {
+		params.Set("pretty", "1")
+	}
+	if s.allowNoIndices != nil {
+		params.Set("allow_no_indices", fmt.Sprintf("%v", *s.allowNoIndices))
+	}
+	if s.analyzeWildcard != nil {
+		params.Set("analyze_wildcard", fmt.Sprintf("%v", *s.analyzeWildcard))
+	}
+	if s.analyzer != "" {
+		params.Set("analyzer", s.analyzer)
+	}
+	if s.defaultOperator != "" {
+		params.Set("default_operator", s.defaultOperator)
 	}
-	if len(typesPart) > 0 {
-		path += "/" + strings.Join(typesPart, ",")
+	if s.df != "" {
+		params.Set("df", s.df)
 	}
+	if s.expandWildcards != "" {
+		params.Set("expand_wildcards", s.expandWildcards)
+	}
+	if s.ignoreUnavailable != nil {
+		params.Set("ignore_unavailable", fmt.Sprintf("%v", *s.ignoreUnavailable))
+	}
+	if s.lenient != nil {
+		params.Set("lenient", fmt.Sprintf("%v", *s.lenient))
+	}
+	if s.lowercaseExpandedTerms != nil {
+		params.Set("lowercase_expanded_terms", fmt.Sprintf("%v", *s.lowercaseExpandedTerms))
+	}
+	if s.minScore != nil {
+		params.Set("min_score", fmt.Sprintf("%v", s.minScore))
+	}
+	if s.preference != "" {
+		params.Set("preference", s.preference)
+	}
+	if s.q != "" {
+		params.Set("q", s.q)
+	}
+	if s.routing != "" {
+		params.Set("routing", s.routing)
+	}
+	return path, params, nil
+}
 
-	// Search
-	path += "/_count"
+// Validate checks if the operation is valid.
+func (s *CountService) Validate() error {
+	return nil
+}
 
-	// Parameters
-	params := make(url.Values)
-	if s.pretty {
-		params.Set("pretty", fmt.Sprintf("%v", s.pretty))
+// Do executes the operation.
+func (s *CountService) Do() (int64, error) {
+	// Check pre-conditions
+	if err := s.Validate(); err != nil {
+		return 0, err
+	}
+
+	// Get URL for request
+	path, params, err := s.buildURL()
+	if err != nil {
+		return 0, err
 	}
 
-	// Set body if there is a query specified
+	// Setup HTTP request body
 	var body interface{}
 	if s.query != nil {
 		src, err := s.query.Source()
@@ -119,16 +279,20 @@ func (s *CountService) Do() (int64, error) {
 		query := make(map[string]interface{})
 		query["query"] = src
 		body = query
+	} else if s.bodyJson != nil {
+		body = s.bodyJson
+	} else if s.bodyString != "" {
+		body = s.bodyString
 	}
 
-	// Get response
+	// Get HTTP response
 	res, err := s.client.PerformRequest("POST", path, params, body)
 	if err != nil {
 		return 0, err
 	}
 
 	// Return result
-	ret := new(CountResult)
+	ret := new(CountResponse)
 	if err := json.Unmarshal(res.Body, ret); err != nil {
 		return 0, err
 	}
@@ -138,3 +302,9 @@ func (s *CountService) Do() (int64, error) {
 
 	return int64(0), nil
 }
+
+// CountResponse is the response of using the Count API.
+type CountResponse struct {
+	Count  int64      `json:"count"`
+	Shards shardsInfo `json:"_shards,omitempty"`
+}