elastic

package module
v2.0.38+incompatible Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 16, 2016 License: MIT Imports: 23 Imported by: 0

README

Elastic

Elastic is an Elasticsearch client for the Go programming language.

Build Status Godoc license

See the wiki for additional information about Elastic.

Releases

The release branches (e.g. release-branch.v2) are actively being worked on and can break at any time. If you want to use stable versions of Elastic, please use the packages released via gopkg.in.

Here's the version matrix:

Elasticsearch version Elastic version - Package URL
2.x 3.0 gopkg.in/olivere/elastic.v3 (source doc)
1.x 2.0 gopkg.in/olivere/elastic.v2 (source doc)
0.9-1.3 1.0 gopkg.in/olivere/elastic.v1 (source doc)

Example:

You have installed Elasticsearch 1.7.4 and want to use Elastic. As listed above, you should use Elastic 2.0. So you first install the stable release of Elastic 2.0 from gopkg.in.

$ go get gopkg.in/olivere/elastic.v2

You then import it with this import path:

import "gopkg.in/olivere/elastic.v2"
Elastic 3.0

Elastic 3.0 targets Elasticsearch 2.0 and later. Elasticsearch 2.0.0 was released on 28th October 2015.

Notice that there are a lot of breaking changes in Elasticsearch 2.0 and we used this as an opportunity to clean up and refactor Elastic as well.

Elastic 2.0

Elastic 2.0 targets Elasticsearch 1.x and published via gopkg.in/olivere/elastic.v2.

Elastic 1.0

Elastic 1.0 is deprecated. You should really update Elasticsearch and Elastic to a recent version.

However, if you cannot update for some reason, don't worry. Version 1.0 is still available. All you need to do is go-get it and change your import path as described above.

Status

We use Elastic in production since 2012. Although Elastic is quite stable from our experience, we don't have a stable API yet. The reason for this is that Elasticsearch changes quite often and at a fast pace. At this moment we focus on features, not on a stable API.

Having said that, there have been no big API changes that required you to rewrite your application big time. More often than not it's renaming APIs and adding/removing features so that we are in sync with the Elasticsearch API.

Elastic has been used in production with the following Elasticsearch versions: 0.90, 1.0-1.7. Furthermore, we use Travis CI to test Elastic with the most recent versions of Elasticsearch and Go. See the .travis.yml file for the exact matrix and Travis for the results.

Elasticsearch has quite a few features. A lot of them are not yet implemented in Elastic (see below for details). I add features and APIs as required. It's straightforward to implement missing pieces. I'm accepting pull requests :-)

Having said that, I hope you find the project useful.

Usage

The first thing you do is to create a Client. The client connects to Elasticsearch on http://127.0.0.1:9200 by default.

You typically create one client for your app. Here's a complete example.

// Create a client
client, err := elastic.NewClient()
if err != nil {
    // Handle error
}

// Create an index
_, err = client.CreateIndex("twitter").Do()
if err != nil {
    // Handle error
    panic(err)
}

// Add a document to the index
tweet := Tweet{User: "olivere", Message: "Take Five"}
_, err = client.Index().
    Index("twitter").
    Type("tweet").
    Id("1").
    BodyJson(tweet).
    Do()
if err != nil {
    // Handle error
    panic(err)
}

// Search with a term query
termQuery := elastic.NewTermQuery("user", "olivere")
searchResult, err := client.Search().
    Index("twitter").   // search in index "twitter"
    Query(&termQuery).  // specify the query
    Sort("user", true). // sort by "user" field, ascending
    From(0).Size(10).   // take documents 0-9
    Pretty(true).       // pretty print request and response JSON
    Do()                // execute
if err != nil {
    // Handle error
    panic(err)
}

// searchResult is of type SearchResult and returns hits, suggestions,
// and all kinds of other information from Elasticsearch.
fmt.Printf("Query took %d milliseconds\n", searchResult.TookInMillis)

// Each is a convenience function that iterates over hits in a search result.
// It makes sure you don't need to check for nil values in the response.
// However, it ignores errors in serialization. If you want full control
// over iterating the hits, see below.
var ttyp Tweet
for _, item := range searchResult.Each(reflect.TypeOf(ttyp)) {
    if t, ok := item.(Tweet); ok {
        fmt.Printf("Tweet by %s: %s\n", t.User, t.Message)
    }
}
// TotalHits is another convenience function that works even when something goes wrong.
fmt.Printf("Found a total of %d tweets\n", searchResult.TotalHits())

// Here's how you iterate through results with full control over each step.
if searchResult.Hits != nil {
    fmt.Printf("Found a total of %d tweets\n", searchResult.Hits.TotalHits)

    // Iterate through results
    for _, hit := range searchResult.Hits.Hits {
        // hit.Index contains the name of the index

        // Deserialize hit.Source into a Tweet (could also be just a map[string]interface{}).
        var t Tweet
        err := json.Unmarshal(*hit.Source, &t)
        if err != nil {
            // Deserialization failed
        }

        // Work with tweet
        fmt.Printf("Tweet by %s: %s\n", t.User, t.Message)
    }
} else {
    // No hits
    fmt.Print("Found no tweets\n")
}

// Delete the index again
_, err = client.DeleteIndex("twitter").Do()
if err != nil {
    // Handle error
    panic(err)
}

See the wiki for more details.

API Status

Here's the current API status.

APIs
  • Search (most queries, filters, facets, aggregations etc. are implemented: see below)
  • Index
  • Get
  • Delete
  • Delete By Query
  • Update
  • Multi Get
  • Bulk
  • Bulk UDP
  • Term vectors
  • Multi term vectors
  • Count
  • Validate
  • Explain
  • Search
  • Search shards
  • Search template
  • Facets (most are implemented, see below)
  • Aggregates (most are implemented, see below)
  • Multi Search
  • Percolate
  • More like this
  • Benchmark
Indices
  • Create index
  • Delete index
  • Get index
  • Indices exists
  • Open/close index
  • Put mapping
  • Get mapping
  • Get field mapping
  • Types exist
  • Delete mapping
  • Index aliases
  • Update indices settings
  • Get settings
  • Analyze
  • Index templates
  • Warmers
  • Status
  • Indices stats
  • Indices segments
  • Indices recovery
  • Clear cache
  • Flush
  • Refresh
  • Optimize
  • Upgrade
Snapshot and Restore
  • Snapshot
  • Restore
  • Snapshot status
  • Monitoring snapshot/restore progress
  • Partial restore
Cat APIs

Not implemented. Those are better suited for operating with Elasticsearch on the command line.

Cluster
  • Health
  • State
  • Stats
  • Pending cluster tasks
  • Cluster reroute
  • Cluster update settings
  • Nodes stats
  • Nodes info
  • Nodes hot_threads
  • Nodes shutdown
  • Inner hits (for ES >= 1.5.0; see docs)
Query DSL
Queries
  • match
  • multi_match
  • bool
  • boosting
  • common_terms
  • constant_score
  • dis_max
  • filtered
  • fuzzy_like_this_query (flt)
  • fuzzy_like_this_field_query (flt_field)
  • function_score
  • fuzzy
  • geo_shape
  • has_child
  • has_parent
  • ids
  • indices
  • match_all
  • mlt
  • mlt_field
  • nested
  • prefix
  • query_string
  • simple_query_string
  • range
  • regexp
  • span_first
  • span_multi_term
  • span_near
  • span_not
  • span_or
  • span_term
  • term
  • terms
  • top_children
  • wildcard
  • minimum_should_match
  • multi_term_query_rewrite
  • template_query
Filters
  • and
  • bool
  • exists
  • geo_bounding_box
  • geo_distance
  • geo_distance_range
  • geo_polygon
  • geoshape
  • geohash
  • has_child
  • has_parent
  • ids
  • indices
  • limit
  • match_all
  • missing
  • nested
  • not
  • or
  • prefix
  • query
  • range
  • regexp
  • script
  • term
  • terms
  • type
Facets
  • Terms
  • Range
  • Histogram
  • Date Histogram
  • Filter
  • Query
  • Statistical
  • Terms Stats
  • Geo Distance
Aggregations
  • min
  • max
  • sum
  • avg
  • stats
  • extended stats
  • value count
  • percentiles
  • percentile ranks
  • cardinality
  • geo bounds
  • top hits
  • scripted metric
  • global
  • filter
  • filters
  • missing
  • nested
  • reverse nested
  • children
  • terms
  • significant terms
  • range
  • date range
  • ipv4 range
  • histogram
  • date histogram
  • geo distance
  • geohash grid
Sorting
  • Sort by score
  • Sort by field
  • Sort by geo distance
  • Sort by script
Scan

Scrolling through documents (e.g. search_type=scan) are implemented via the Scroll and Scan services. The ClearScroll API is implemented as well.

How to contribute

Read the contribution guidelines.

Credits

Thanks a lot for the great folks working hard on Elasticsearch and Go.

Elastic uses portions of the uritemplates library by Joshua Tacoma and backoff by Cenk Altı.

LICENSE

MIT-LICENSE. See LICENSE or the LICENSE file provided in the repository for details.

Documentation

Overview

Package elastic provides an interface to the Elasticsearch server (http://www.elasticsearch.org/).

The first thing you do is to create a Client. If you have Elasticsearch installed and running with its default settings (i.e. available at http://127.0.0.1:9200), all you need to do is: 

client, err := elastic.NewClient()
if err != nil {
	// Handle error
}

If your Elasticsearch server is running on a different IP and/or port, just provide a URL to NewClient: 

// Create a client and connect to http://192.168.2.10:9201
client, err := elastic.NewClient(elastic.SetURL("http://192.168.2.10:9201"))
if err != nil {
  // Handle error
}

You can pass many more configuration parameters to NewClient. Review the documentation of NewClient for more information.

If no Elasticsearch server is available, services will fail when creating a new request and will return ErrNoClient.

A Client provides services. The services usually come with a variety of methods to prepare the query and a Do function to execute it against the Elasticsearch REST interface and return a response. Here is an example of the IndexExists service that checks if a given index already exists. 

exists, err := client.IndexExists("twitter").Do()
if err != nil {
	// Handle error
}
if !exists {
	// Index does not exist yet.
}

Look up the documentation for Client to get an idea of the services provided and what kinds of responses you get when executing the Do function of a service. Also see the wiki on Github for more details.

Example 
package main

import (
	"encoding/json"
	"fmt"
	"log"
	"os"
	"reflect"
	"time"

	elastic "gopkg.in/olivere/elastic.v2"
)

type Tweet struct {
	User     string                `json:"user"`
	Message  string                `json:"message"`
	Retweets int                   `json:"retweets"`
	Image    string                `json:"image,omitempty"`
	Created  time.Time             `json:"created,omitempty"`
	Tags     []string              `json:"tags,omitempty"`
	Location string                `json:"location,omitempty"`
	Suggest  *elastic.SuggestField `json:"suggest_field,omitempty"`
}

func main() {
	errorlog := log.New(os.Stdout, "APP ", log.LstdFlags)

	// Obtain a client. You can provide your own HTTP client here.
	client, err := elastic.NewClient(elastic.SetErrorLog(errorlog))
	if err != nil {
		// Handle error
		panic(err)
	}

	// Trace request and response details like this
	//client.SetTracer(log.New(os.Stdout, "", 0))

	// Ping the Elasticsearch server to get e.g. the version number
	info, code, err := client.Ping().Do()
	if err != nil {
		// Handle error
		panic(err)
	}
	fmt.Printf("Elasticsearch returned with code %d and version %s", code, info.Version.Number)

	// Getting the ES version number is quite common, so there's a shortcut
	esversion, err := client.ElasticsearchVersion("http://127.0.0.1:9200")
	if err != nil {
		// Handle error
		panic(err)
	}
	fmt.Printf("Elasticsearch version %s", esversion)

	// Use the IndexExists service to check if a specified index exists.
	exists, err := client.IndexExists("twitter").Do()
	if err != nil {
		// Handle error
		panic(err)
	}
	if !exists {
		// Create a new index.
		createIndex, err := client.CreateIndex("twitter").Do()
		if err != nil {
			// Handle error
			panic(err)
		}
		if !createIndex.Acknowledged {
			// Not acknowledged
		}
	}

	// Index a tweet (using JSON serialization)
	tweet1 := Tweet{User: "olivere", Message: "Take Five", Retweets: 0}
	put1, err := client.Index().
		Index("twitter").
		Type("tweet").
		Id("1").
		BodyJson(tweet1).
		Do()
	if err != nil {
		// Handle error
		panic(err)
	}
	fmt.Printf("Indexed tweet %s to index %s, type %s\n", put1.Id, put1.Index, put1.Type)

	// Index a second tweet (by string)
	tweet2 := `{"user" : "olivere", "message" : "It's a Raggy Waltz"}`
	put2, err := client.Index().
		Index("twitter").
		Type("tweet").
		Id("2").
		BodyString(tweet2).
		Do()
	if err != nil {
		// Handle error
		panic(err)
	}
	fmt.Printf("Indexed tweet %s to index %s, type %s\n", put2.Id, put2.Index, put2.Type)

	// Get tweet with specified ID
	get1, err := client.Get().
		Index("twitter").
		Type("tweet").
		Id("1").
		Do()
	if err != nil {
		// Handle error
		panic(err)
	}
	if get1.Found {
		fmt.Printf("Got document %s in version %d from index %s, type %s\n", get1.Id, get1.Version, get1.Index, get1.Type)
	}

	// Flush to make sure the documents got written.
	_, err = client.Flush().Index("twitter").Do()
	if err != nil {
		panic(err)
	}

	// Search with a term query
	termQuery := elastic.NewTermQuery("user", "olivere")
	searchResult, err := client.Search().
		Index("twitter").   // search in index "twitter"
		Query(&termQuery).  // specify the query
		Sort("user", true). // sort by "user" field, ascending
		From(0).Size(10).   // take documents 0-9
		Pretty(true).       // pretty print request and response JSON
		Do()                // execute
	if err != nil {
		// Handle error
		panic(err)
	}

	// searchResult is of type SearchResult and returns hits, suggestions,
	// and all kinds of other information from Elasticsearch.
	fmt.Printf("Query took %d milliseconds\n", searchResult.TookInMillis)

	// Each is a convenience function that iterates over hits in a search result.
	// It makes sure you don't need to check for nil values in the response.
	// However, it ignores errors in serialization. If you want full control
	// over iterating the hits, see below.
	var ttyp Tweet
	for _, item := range searchResult.Each(reflect.TypeOf(ttyp)) {
		t := item.(Tweet)
		fmt.Printf("Tweet by %s: %s\n", t.User, t.Message)
	}
	// TotalHits is another convenience function that works even when something goes wrong.
	fmt.Printf("Found a total of %d tweets\n", searchResult.TotalHits())

	// Here's how you iterate through results with full control over each step.
	if searchResult.Hits != nil {
		fmt.Printf("Found a total of %d tweets\n", searchResult.Hits.TotalHits)

		// Iterate through results
		for _, hit := range searchResult.Hits.Hits {
			// hit.Index contains the name of the index

			// Deserialize hit.Source into a Tweet (could also be just a map[string]interface{}).
			var t Tweet
			err := json.Unmarshal(*hit.Source, &t)
			if err != nil {
				// Deserialization failed
			}

			// Work with tweet
			fmt.Printf("Tweet by %s: %s\n", t.User, t.Message)
		}
	} else {
		// No hits
		fmt.Print("Found no tweets\n")
	}

	// Update a tweet by the update API of Elasticsearch.
	// We just increment the number of retweets.
	update, err := client.Update().Index("twitter").Type("tweet").Id("1").
		Script("ctx._source.retweets += num").
		ScriptParams(map[string]interface{}{"num": 1}).
		Upsert(map[string]interface{}{"retweets": 0}).
		Do()
	if err != nil {
		// Handle error
		panic(err)
	}
	fmt.Printf("New version of tweet %q is now %d", update.Id, update.Version)

	// ...

	// Delete an index.
	deleteIndex, err := client.DeleteIndex("twitter").Do()
	if err != nil {
		// Handle error
		panic(err)
	}
	if !deleteIndex.Acknowledged {
		// Not acknowledged
	}
}

Output:

Index

Examples

Constants

View Source 
const (
	// Version is the current version of Elastic.
	Version = "2.0.38"

	// 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.
	DefaultURL = "http://127.0.0.1:9200"

	// DefaultScheme is the default protocol scheme to use when sniffing
	// the Elasticsearch cluster.
	DefaultScheme = "http"

	// DefaultHealthcheckEnabled specifies if healthchecks are enabled by default.
	DefaultHealthcheckEnabled = true

	// DefaultHealthcheckTimeoutStartup is the time the healthcheck waits
	// for a response from Elasticsearch on startup, i.e. when creating a
	// client. After the client is started, a shorter timeout is commonly used
	// (its default is specified in DefaultHealthcheckTimeout).
	DefaultHealthcheckTimeoutStartup = 5 * time.Second

	// DefaultHealthcheckTimeout specifies the time a running client waits for
	// a response from Elasticsearch. Notice that the healthcheck timeout
	// when a client is created is larger by default (see DefaultHealthcheckTimeoutStartup).
	DefaultHealthcheckTimeout = 1 * time.Second

	// DefaultHealthcheckInterval is the default interval between
	// two health checks of the nodes in the cluster.
	DefaultHealthcheckInterval = 60 * time.Second

	// DefaultSnifferEnabled specifies if the sniffer is enabled by default.
	DefaultSnifferEnabled = true

	// DefaultSnifferInterval is the interval between two sniffing procedures,
	// i.e. the lookup of all nodes in the cluster and their addition/removal
	// from the list of actual connections.
	DefaultSnifferInterval = 15 * time.Minute

	// DefaultSnifferTimeoutStartup is the default timeout for the sniffing
	// process that is initiated while creating a new client. For subsequent
	// sniffing processes, DefaultSnifferTimeout is used (by default).
	DefaultSnifferTimeoutStartup = 5 * time.Second

	// DefaultSnifferTimeout is the default timeout after which the
	// sniffing process times out. Notice that for the initial sniffing
	// process, DefaultSnifferTimeoutStartup is used.
	DefaultSnifferTimeout = 2 * time.Second

	// DefaultMaxRetries is the number of retries for a single request after
	// Elastic will give up and return an error. It is zero by default, so
	// retry is disabled by default.
	DefaultMaxRetries = 0

	// DefaultSendGetBodyAs is the HTTP method to use when elastic is sending
	// a GET request with a body.
	DefaultSendGetBodyAs = "GET"

	// DefaultGzipEnabled specifies if gzip compression is enabled by default.
	DefaultGzipEnabled = false
)

Variables

View Source 
var (
	// ErrNoClient is raised when no Elasticsearch node is available.
	ErrNoClient = errors.New("no Elasticsearch node available")

	// ErrRetry is raised when a request cannot be executed after the configured
	// number of retries.
	ErrRetry = errors.New("cannot connect after several retries")

	// ErrTimeout is raised when a request timed out, e.g. when WaitForStatus
	// didn't return in time.
	ErrTimeout = errors.New("timeout")
)
View Source 
var (
	// ErrMissingIndex is returned e.g. from DeleteService if the index is missing.
	ErrMissingIndex = errors.New("elastic: index is missing")

	// ErrMissingType is returned e.g. from DeleteService if the type is missing.
	ErrMissingType = errors.New("elastic: type is missing")

	// ErrMissingId is returned e.g. from DeleteService if the document identifier is missing.
	ErrMissingId = errors.New("elastic: id is missing")
)
View Source 
var (
	// End of stream (or scan)
	EOS = errors.New("EOS")

	// No ScrollId
	ErrNoScrollId = errors.New("no scrollId")
)

Functions

This section is empty.

Types

type Aggregation 

type Aggregation interface {
	Source() interface{}
}

Aggregations can be seen as a unit-of-work that build analytic information over a set of documents. It is (in many senses) the follow-up of facets in Elasticsearch. For more details about aggregations, visit: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations.html

type AggregationBucketFilters 

type AggregationBucketFilters struct {
	Aggregations

	Buckets      []*AggregationBucketKeyItem          //`json:"buckets"`
	NamedBuckets map[string]*AggregationBucketKeyItem //`json:"buckets"`
}

AggregationBucketFilters is a multi-bucket aggregation that is returned with a filters aggregation.

func (*AggregationBucketFilters) UnmarshalJSON 

func (a *AggregationBucketFilters) UnmarshalJSON(data []byte) error

UnmarshalJSON decodes JSON data and initializes an AggregationBucketFilters structure.

type AggregationBucketHistogramItem 

type AggregationBucketHistogramItem struct {
	Aggregations

	Key         int64   //`json:"key"`
	KeyAsString *string //`json:"key_as_string"`
	DocCount    int64   //`json:"doc_count"`
}

AggregationBucketHistogramItem is a single bucket of an AggregationBucketHistogramItems structure.

func (*AggregationBucketHistogramItem) UnmarshalJSON 

func (a *AggregationBucketHistogramItem) UnmarshalJSON(data []byte) error

UnmarshalJSON decodes JSON data and initializes an AggregationBucketHistogramItem structure.

type AggregationBucketHistogramItems 

type AggregationBucketHistogramItems struct {
	Aggregations

	Buckets []*AggregationBucketHistogramItem //`json:"buckets"`
}

AggregationBucketHistogramItems is a bucket aggregation that is returned with a date histogram aggregation.

func (*AggregationBucketHistogramItems) UnmarshalJSON 

func (a *AggregationBucketHistogramItems) UnmarshalJSON(data []byte) error

UnmarshalJSON decodes JSON data and initializes an AggregationBucketHistogramItems structure.

type AggregationBucketKeyItem 

type AggregationBucketKeyItem struct {
	Aggregations

	Key       interface{} //`json:"key"`
	KeyNumber json.Number
	DocCount  int64 //`json:"doc_count"`
}

AggregationBucketKeyItem is a single bucket of an AggregationBucketKeyItems structure.

func (*AggregationBucketKeyItem) UnmarshalJSON 

func (a *AggregationBucketKeyItem) UnmarshalJSON(data []byte) error

UnmarshalJSON decodes JSON data and initializes an AggregationBucketKeyItem structure.

type AggregationBucketKeyItems 

type AggregationBucketKeyItems struct {
	Aggregations

	DocCountErrorUpperBound int64                       //`json:"doc_count_error_upper_bound"`
	SumOfOtherDocCount      int64                       //`json:"sum_other_doc_count"`
	Buckets                 []*AggregationBucketKeyItem //`json:"buckets"`
}

AggregationBucketKeyItems is a bucket aggregation that is e.g. returned with a terms aggregation.

func (*AggregationBucketKeyItems) UnmarshalJSON 

func (a *AggregationBucketKeyItems) UnmarshalJSON(data []byte) error

UnmarshalJSON decodes JSON data and initializes an AggregationBucketKeyItems structure.

type AggregationBucketKeyedRangeItems 

type AggregationBucketKeyedRangeItems struct {
	Aggregations

	DocCountErrorUpperBound int64                                  //`json:"doc_count_error_upper_bound"`
	SumOfOtherDocCount      int64                                  //`json:"sum_other_doc_count"`
	Buckets                 map[string]*AggregationBucketRangeItem //`json:"buckets"`
}

AggregationBucketKeyedRangeItems is a bucket aggregation that is e.g. returned with a keyed range aggregation.

func (*AggregationBucketKeyedRangeItems) UnmarshalJSON 

func (a *AggregationBucketKeyedRangeItems) UnmarshalJSON(data []byte) error

UnmarshalJSON decodes JSON data and initializes an AggregationBucketRangeItems structure.

type AggregationBucketRangeItem 

type AggregationBucketRangeItem struct {
	Aggregations

	Key          string   //`json:"key"`
	DocCount     int64    //`json:"doc_count"`
	From         *float64 //`json:"from"`
	FromAsString string   //`json:"from_as_string"`
	To           *float64 //`json:"to"`
	ToAsString   string   //`json:"to_as_string"`
}

AggregationBucketRangeItem is a single bucket of an AggregationBucketRangeItems structure.

func (*AggregationBucketRangeItem) UnmarshalJSON 

func (a *AggregationBucketRangeItem) UnmarshalJSON(data []byte) error

UnmarshalJSON decodes JSON data and initializes an AggregationBucketRangeItem structure.

type AggregationBucketRangeItems 

type AggregationBucketRangeItems struct {
	Aggregations

	DocCountErrorUpperBound int64                         //`json:"doc_count_error_upper_bound"`
	SumOfOtherDocCount      int64                         //`json:"sum_other_doc_count"`
	Buckets                 []*AggregationBucketRangeItem //`json:"buckets"`
}

AggregationBucketRangeItems is a bucket aggregation that is e.g. returned with a range aggregation.

func (*AggregationBucketRangeItems) UnmarshalJSON 

func (a *AggregationBucketRangeItems) UnmarshalJSON(data []byte) error

UnmarshalJSON decodes JSON data and initializes an AggregationBucketRangeItems structure.

type AggregationBucketSignificantTerm 

type AggregationBucketSignificantTerm struct {
	Aggregations

	Key      string  //`json:"key"`
	DocCount int64   //`json:"doc_count"`
	BgCount  int64   //`json:"bg_count"`
	Score    float64 //`json:"score"`
}

AggregationBucketSignificantTerm is a single bucket of an AggregationBucketSignificantTerms structure.

func (*AggregationBucketSignificantTerm) UnmarshalJSON 

func (a *AggregationBucketSignificantTerm) UnmarshalJSON(data []byte) error

UnmarshalJSON decodes JSON data and initializes an AggregationBucketSignificantTerm structure.

type AggregationBucketSignificantTerms 

type AggregationBucketSignificantTerms struct {
	Aggregations

	DocCount int64                               //`json:"doc_count"`
	Buckets  []*AggregationBucketSignificantTerm //`json:"buckets"`
}

AggregationBucketSignificantTerms is a bucket aggregation returned with a significant terms aggregation.

func (*AggregationBucketSignificantTerms) UnmarshalJSON 

func (a *AggregationBucketSignificantTerms) UnmarshalJSON(data []byte) error

UnmarshalJSON decodes JSON data and initializes an AggregationBucketSignificantTerms structure.

type AggregationExtendedStatsMetric 

type AggregationExtendedStatsMetric struct {
	Aggregations

	Count        int64    // `json:"count"`
	Min          *float64 //`json:"min,omitempty"`
	Max          *float64 //`json:"max,omitempty"`
	Avg          *float64 //`json:"avg,omitempty"`
	Sum          *float64 //`json:"sum,omitempty"`
	SumOfSquares *float64 //`json:"sum_of_squares,omitempty"`
	Variance     *float64 //`json:"variance,omitempty"`
	StdDeviation *float64 //`json:"std_deviation,omitempty"`
}

AggregationExtendedStatsMetric is a multi-value metric, returned by an ExtendedStats aggregation.

func (*AggregationExtendedStatsMetric) UnmarshalJSON 

func (a *AggregationExtendedStatsMetric) UnmarshalJSON(data []byte) error

UnmarshalJSON decodes JSON data and initializes an AggregationExtendedStatsMetric structure.

type AggregationGeoBoundsMetric 

type AggregationGeoBoundsMetric struct {
	Aggregations

	Bounds struct {
		TopLeft struct {
			Latitude  float64 `json:"lat"`
			Longitude float64 `json:"lon"`
		} `json:"top_left"`
		BottomRight struct {
			Latitude  float64 `json:"lat"`
			Longitude float64 `json:"lon"`
		} `json:"bottom_right"`
	} `json:"bounds"`
}

AggregationGeoBoundsMetric is a metric as returned by a GeoBounds aggregation.

func (*AggregationGeoBoundsMetric) UnmarshalJSON 

func (a *AggregationGeoBoundsMetric) UnmarshalJSON(data []byte) error

UnmarshalJSON decodes JSON data and initializes an AggregationGeoBoundsMetric structure.

type AggregationPercentilesMetric 

type AggregationPercentilesMetric struct {
	Aggregations

	Values map[string]float64 // `json:"values"`
}

AggregationPercentilesMetric is a multi-value metric, returned by a Percentiles aggregation.

func (*AggregationPercentilesMetric) UnmarshalJSON 

func (a *AggregationPercentilesMetric) UnmarshalJSON(data []byte) error

UnmarshalJSON decodes JSON data and initializes an AggregationPercentilesMetric structure.

type AggregationSingleBucket 

type AggregationSingleBucket struct {
	Aggregations

	DocCount int64 // `json:"doc_count"`
}

AggregationSingleBucket is a single bucket, returned e.g. via an aggregation of type Global.

func (*AggregationSingleBucket) UnmarshalJSON 

func (a *AggregationSingleBucket) UnmarshalJSON(data []byte) error

UnmarshalJSON decodes JSON data and initializes an AggregationSingleBucket structure.

type AggregationStatsMetric 

type AggregationStatsMetric struct {
	Aggregations

	Count int64    // `json:"count"`
	Min   *float64 //`json:"min,omitempty"`
	Max   *float64 //`json:"max,omitempty"`
	Avg   *float64 //`json:"avg,omitempty"`
	Sum   *float64 //`json:"sum,omitempty"`
}

AggregationStatsMetric is a multi-value metric, returned by a Stats aggregation.

func (*AggregationStatsMetric) UnmarshalJSON 

func (a *AggregationStatsMetric) UnmarshalJSON(data []byte) error

UnmarshalJSON decodes JSON data and initializes an AggregationStatsMetric structure.

type AggregationTopHitsMetric 

type AggregationTopHitsMetric struct {
	Aggregations

	Hits *SearchHits //`json:"hits"`
}

AggregationTopHitsMetric is a metric returned by a TopHits aggregation.

func (*AggregationTopHitsMetric) UnmarshalJSON 

func (a *AggregationTopHitsMetric) UnmarshalJSON(data []byte) error

UnmarshalJSON decodes JSON data and initializes an AggregationTopHitsMetric structure.

type AggregationValueMetric 

type AggregationValueMetric struct {
	Aggregations

	Value *float64 //`json:"value"`
}

AggregationValueMetric is a single-value metric, returned e.g. by a Min or Max aggregation.

func (*AggregationValueMetric) UnmarshalJSON 

func (a *AggregationValueMetric) UnmarshalJSON(data []byte) error

UnmarshalJSON decodes JSON data and initializes an AggregationValueMetric structure.

type Aggregations 

type Aggregations map[string]*json.RawMessage

Aggregations is a list of aggregations that are part of a search result.

Example 
package main

import (
	"fmt"
	"log"

	elastic "gopkg.in/olivere/elastic.v2"
)

func main() {
	// Get a client to the local Elasticsearch instance.
	client, err := elastic.NewClient()
	if err != nil {
		// Handle error
		panic(err)
	}

	// Create an aggregation for users and a sub-aggregation for a date histogram of tweets (per year).
	timeline := elastic.NewTermsAggregation().Field("user").Size(10).OrderByCountDesc()
	histogram := elastic.NewDateHistogramAggregation().Field("created").Interval("year")
	timeline = timeline.SubAggregation("history", histogram)

	// Search with a term query
	searchResult, err := client.Search().
		Index("twitter").                  // search in index "twitter"
		Query(elastic.NewMatchAllQuery()). // return all results, but ...
		SearchType("count").               // ... do not return hits, just the count
		Aggregation("timeline", timeline). // add our aggregation to the query
		Pretty(true).                      // pretty print request and response JSON
		Do()                               // execute
	if err != nil {
		// Handle error
		panic(err)
	}

	// Access "timeline" aggregate in search result.
	agg, found := searchResult.Aggregations.Terms("timeline")
	if !found {
		log.Fatalf("we sould have a terms aggregation called %q", "timeline")
	}
	for _, userBucket := range agg.Buckets {
		// Every bucket should have the user field as key.
		user := userBucket.Key

		// The sub-aggregation history should have the number of tweets per year.
		histogram, found := userBucket.DateHistogram("history")
		if found {
			for _, year := range histogram.Buckets {
				fmt.Printf("user %q has %d tweets in %q\n", user, year.DocCount, year.KeyAsString)
			}
		}
	}
}

Output:

func (Aggregations) Avg 

func (a Aggregations) Avg(name string) (*AggregationValueMetric, bool)

Avg returns average aggregation results. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-metrics-avg-aggregation.html

func (Aggregations) Cardinality 

func (a Aggregations) Cardinality(name string) (*AggregationValueMetric, bool)

Cardinality returns cardinality aggregation results. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-metrics-cardinality-aggregation.html

func (Aggregations) Children 

func (a Aggregations) Children(name string) (*AggregationSingleBucket, bool)

Children returns children results. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-children-aggregation.html

func (Aggregations) DateHistogram 

func (a Aggregations) DateHistogram(name string) (*AggregationBucketHistogramItems, bool)

DateHistogram returns date histogram aggregation results. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-datehistogram-aggregation.html

func (Aggregations) DateRange 

func (a Aggregations) DateRange(name string) (*AggregationBucketRangeItems, bool)

DateRange returns date range aggregation results. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-daterange-aggregation.html

func (Aggregations) ExtendedStats 

func (a Aggregations) ExtendedStats(name string) (*AggregationExtendedStatsMetric, bool)

ExtendedStats returns extended stats aggregation results. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-metrics-extendedstats-aggregation.html

func (Aggregations) Filter 

func (a Aggregations) Filter(name string) (*AggregationSingleBucket, bool)

Filter returns filter results. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-filter-aggregation.html

func (Aggregations) Filters 

func (a Aggregations) Filters(name string) (*AggregationBucketFilters, bool)

Filters returns filters results. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-filters-aggregation.html

func (Aggregations) GeoBounds 

func (a Aggregations) GeoBounds(name string) (*AggregationGeoBoundsMetric, bool)

GeoBounds returns geo-bounds aggregation results. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-metrics-geobounds-aggregation.html

func (Aggregations) GeoDistance 

func (a Aggregations) GeoDistance(name string) (*AggregationBucketRangeItems, bool)

GeoDistance returns geo distance aggregation results. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-geodistance-aggregation.html

func (Aggregations) GeoHash 

func (a Aggregations) GeoHash(name string) (*AggregationBucketKeyItems, bool)

GeoHash returns geo-hash aggregation results. http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-geohashgrid-aggregation.html

func (Aggregations) Global 

func (a Aggregations) Global(name string) (*AggregationSingleBucket, bool)

Global returns global results. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-global-aggregation.html

func (Aggregations) Histogram 

func (a Aggregations) Histogram(name string) (*AggregationBucketHistogramItems, bool)

Histogram returns histogram aggregation results. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-histogram-aggregation.html

func (Aggregations) IPv4Range 

func (a Aggregations) IPv4Range(name string) (*AggregationBucketRangeItems, bool)

IPv4Range returns IPv4 range aggregation results. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-iprange-aggregation.html

func (Aggregations) KeyedRange 

func (a Aggregations) KeyedRange(name string) (*AggregationBucketKeyedRangeItems, bool)

KeyedRange returns keyed range aggregation results. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-range-aggregation.html.

func (Aggregations) Max 

func (a Aggregations) Max(name string) (*AggregationValueMetric, bool)

Max returns max aggregation results. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-metrics-max-aggregation.html

func (Aggregations) Min 

func (a Aggregations) Min(name string) (*AggregationValueMetric, bool)

Min returns min aggregation results. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-metrics-min-aggregation.html

func (Aggregations) Missing 

func (a Aggregations) Missing(name string) (*AggregationSingleBucket, bool)

Missing returns missing results. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-missing-aggregation.html

func (Aggregations) Nested 

func (a Aggregations) Nested(name string) (*AggregationSingleBucket, bool)

Nested returns nested results. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-nested-aggregation.html

func (Aggregations) PercentileRanks 

func (a Aggregations) PercentileRanks(name string) (*AggregationPercentilesMetric, bool)

PercentileRanks returns percentile ranks results. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-metrics-percentile-rank-aggregation.html

func (Aggregations) Percentiles 

func (a Aggregations) Percentiles(name string) (*AggregationPercentilesMetric, bool)

Percentiles returns percentiles results. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-metrics-percentile-aggregation.html

func (Aggregations) Range 

func (a Aggregations) Range(name string) (*AggregationBucketRangeItems, bool)

Range returns range aggregation results. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-range-aggregation.html

func (Aggregations) ReverseNested 

func (a Aggregations) ReverseNested(name string) (*AggregationSingleBucket, bool)

ReverseNested returns reverse-nested results. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-reverse-nested-aggregation.html

func (Aggregations) SignificantTerms 

func (a Aggregations) SignificantTerms(name string) (*AggregationBucketSignificantTerms, bool)

SignificantTerms returns significant terms aggregation results. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-significantterms-aggregation.html

func (Aggregations) Stats 

func (a Aggregations) Stats(name string) (*AggregationStatsMetric, bool)

Stats returns stats aggregation results. http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-metrics-stats-aggregation.html

func (Aggregations) Sum 

func (a Aggregations) Sum(name string) (*AggregationValueMetric, bool)

Sum returns sum aggregation results. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-metrics-sum-aggregation.html

func (Aggregations) Terms 

func (a Aggregations) Terms(name string) (*AggregationBucketKeyItems, bool)

Terms returns terms aggregation results. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-terms-aggregation.html

func (Aggregations) TopHits 

func (a Aggregations) TopHits(name string) (*AggregationTopHitsMetric, bool)

TopHits returns top-hits aggregation results. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-metrics-top-hits-aggregation.html

func (Aggregations) ValueCount 

func (a Aggregations) ValueCount(name string) (*AggregationValueMetric, bool)

ValueCount returns value-count aggregation results. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-metrics-valuecount-aggregation.html

type AliasResult 

type AliasResult struct {
	Acknowledged bool `json:"acknowledged"`
}

type AliasService 

type AliasService struct {
	// contains filtered or unexported fields
}

func NewAliasService 

func NewAliasService(client *Client) *AliasService

func (*AliasService) Add 

func (s *AliasService) Add(indexName string, aliasName string) *AliasService

func (*AliasService) AddWithFilter 

func (s *AliasService) AddWithFilter(indexName string, aliasName string, filter *Filter) *AliasService

func (*AliasService) Do 

func (s *AliasService) Do() (*AliasResult, error)

func (*AliasService) Pretty 

func (s *AliasService) Pretty(pretty bool) *AliasService

func (*AliasService) Remove 

func (s *AliasService) Remove(indexName string, aliasName string) *AliasService

type AliasesResult 

type AliasesResult struct {
	Indices map[string]indexResult
}

func (AliasesResult) IndicesByAlias 

func (ar AliasesResult) IndicesByAlias(aliasName string) []string

type AliasesService 

type AliasesService struct {
	// contains filtered or unexported fields
}

func NewAliasesService 

func NewAliasesService(client *Client) *AliasesService

func (*AliasesService) Do 

func (s *AliasesService) Do() (*AliasesResult, error)

func (*AliasesService) Index 

func (s *AliasesService) Index(indexName string) *AliasesService

func (*AliasesService) Indices 

func (s *AliasesService) Indices(indexNames ...string) *AliasesService

func (*AliasesService) Pretty 

func (s *AliasesService) Pretty(pretty bool) *AliasesService

type AndFilter 

type AndFilter struct {
	// contains filtered or unexported fields
}

A filter that matches documents using AND boolean operator on other filters. Can be placed within queries that accept a filter. For details, see: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-and-filter.html

func NewAndFilter 

func NewAndFilter(filters ...Filter) AndFilter

func (AndFilter) Add 

func (f AndFilter) Add(filter Filter) AndFilter

func (AndFilter) Cache 

func (f AndFilter) Cache(cache bool) AndFilter

func (AndFilter) CacheKey 

func (f AndFilter) CacheKey(cacheKey string) AndFilter

func (AndFilter) FilterName 

func (f AndFilter) FilterName(filterName string) AndFilter

func (AndFilter) Source 

func (f AndFilter) Source() interface{}

type AvgAggregation 

type AvgAggregation struct {
	// contains filtered or unexported fields
}

AvgAggregation is a single-value metrics aggregation that computes the average of numeric values that are extracted from the aggregated documents. These values can be extracted either from specific numeric fields in the documents, or be generated by a provided script. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-metrics-avg-aggregation.html

func NewAvgAggregation 

func NewAvgAggregation() AvgAggregation

func (AvgAggregation) Field 

func (a AvgAggregation) Field(field string) AvgAggregation

func (AvgAggregation) Format 

func (a AvgAggregation) Format(format string) AvgAggregation

func (AvgAggregation) Lang 

func (a AvgAggregation) Lang(lang string) AvgAggregation

func (AvgAggregation) Param 

func (a AvgAggregation) Param(name string, value interface{}) AvgAggregation

func (AvgAggregation) Script 

func (a AvgAggregation) Script(script string) AvgAggregation

func (AvgAggregation) ScriptFile 

func (a AvgAggregation) ScriptFile(scriptFile string) AvgAggregation

func (AvgAggregation) Source 

func (a AvgAggregation) Source() interface{}

func (AvgAggregation) SubAggregation 

func (a AvgAggregation) SubAggregation(name string, subAggregation Aggregation) AvgAggregation

type BoolFilter 

type BoolFilter struct {
	// contains filtered or unexported fields
}

A filter that matches documents matching boolean combinations of other queries. Similar in concept to Boolean query, except that the clauses are other filters. Can be placed within queries that accept a filter. For more details, see: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-bool-filter.html

func NewBoolFilter 

func NewBoolFilter() BoolFilter

NewBoolFilter creates a new bool filter.

func (BoolFilter) Cache 

func (f BoolFilter) Cache(cache bool) BoolFilter

func (BoolFilter) CacheKey 

func (f BoolFilter) CacheKey(cacheKey string) BoolFilter

func (BoolFilter) FilterName 

func (f BoolFilter) FilterName(filterName string) BoolFilter

func (BoolFilter) Must 

func (f BoolFilter) Must(filters ...Filter) BoolFilter

func (BoolFilter) MustNot 

func (f BoolFilter) MustNot(filters ...Filter) BoolFilter

func (BoolFilter) Should 

func (f BoolFilter) Should(filters ...Filter) BoolFilter

func (BoolFilter) Source 

func (f BoolFilter) Source() interface{}

Creates the query source for the bool query.

type BoolQuery 

type BoolQuery struct {
	Query
	// contains filtered or unexported fields
}

A bool query matches documents matching boolean combinations of other queries. For more details, see: http://www.elasticsearch.org/guide/reference/query-dsl/bool-query.html

func NewBoolQuery 

func NewBoolQuery() BoolQuery

Creates a new bool query.

func (BoolQuery) AdjustPureNegative 

func (q BoolQuery) AdjustPureNegative(adjustPureNegative bool) BoolQuery

func (BoolQuery) Boost 

func (q BoolQuery) Boost(boost float32) BoolQuery

func (BoolQuery) DisableCoord 

func (q BoolQuery) DisableCoord(disableCoord bool) BoolQuery

func (BoolQuery) MinimumShouldMatch 

func (q BoolQuery) MinimumShouldMatch(minimumShouldMatch string) BoolQuery

func (BoolQuery) Must 

func (q BoolQuery) Must(queries ...Query) BoolQuery

func (BoolQuery) MustNot 

func (q BoolQuery) MustNot(queries ...Query) BoolQuery

func (BoolQuery) QueryName 

func (q BoolQuery) QueryName(queryName string) BoolQuery

func (BoolQuery) Should 

func (q BoolQuery) Should(queries ...Query) BoolQuery

func (BoolQuery) Source 

func (q BoolQuery) Source() interface{}

Creates the query source for the bool query.

type BoostingQuery 

type BoostingQuery struct {
	Query
	// contains filtered or unexported fields
}

A boosting query can be used to effectively demote results that match a given query. For more details, see: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-boosting-query.html

func NewBoostingQuery 

func NewBoostingQuery() BoostingQuery

Creates a new boosting query.

func (BoostingQuery) Boost 

func (q BoostingQuery) Boost(boost float64) BoostingQuery

func (BoostingQuery) Negative 

func (q BoostingQuery) Negative(negative Query) BoostingQuery

func (BoostingQuery) NegativeBoost 

func (q BoostingQuery) NegativeBoost(negativeBoost float64) BoostingQuery

func (BoostingQuery) Positive 

func (q BoostingQuery) Positive(positive Query) BoostingQuery

func (BoostingQuery) Source 

func (q BoostingQuery) Source() interface{}

Creates the query source for the boosting query.

type BulkAfterFunc 

type BulkAfterFunc func(executionId int64, requests []BulkableRequest, response *BulkResponse, err error)

BulkAfterFunc defines the signature of callbacks that are executed after a commit to Elasticsearch. The err parameter signals an error.

type BulkBeforeFunc 

type BulkBeforeFunc func(executionId int64, requests []BulkableRequest)

BulkBeforeFunc defines the signature of callbacks that are executed before a commit to Elasticsearch.

type BulkDeleteRequest 

type BulkDeleteRequest struct {
	BulkableRequest
	// contains filtered or unexported fields
}

Bulk request to remove a document from Elasticsearch.

See https://www.elastic.co/guide/en/elasticsearch/reference/1.7/docs-bulk.html for details.

func NewBulkDeleteRequest 

func NewBulkDeleteRequest() *BulkDeleteRequest

NewBulkDeleteRequest returns a new BulkDeleteRequest.

func (*BulkDeleteRequest) Id 

func (r *BulkDeleteRequest) Id(id string) *BulkDeleteRequest

Id specifies the identifier of the document to delete.

func (*BulkDeleteRequest) Index 

func (r *BulkDeleteRequest) Index(index string) *BulkDeleteRequest

Index specifies the Elasticsearch index to use for this delete request. If unspecified, the index set on the BulkService will be used.

func (*BulkDeleteRequest) Refresh 

func (r *BulkDeleteRequest) Refresh(refresh bool) *BulkDeleteRequest

Refresh indicates whether to update the shards immediately after the delete has been processed. Deleted documents will disappear in search immediately at the cost of slower bulk performance.

func (*BulkDeleteRequest) Routing 

func (r *BulkDeleteRequest) Routing(routing string) *BulkDeleteRequest

Routing specifies a routing value for the request.

func (*BulkDeleteRequest) Source 

func (r *BulkDeleteRequest) Source() ([]string, error)

Source returns the on-wire representation of the delete request, split into an action-and-meta-data line and an (optional) source line. See https://www.elastic.co/guide/en/elasticsearch/reference/1.7/docs-bulk.html for details.

func (*BulkDeleteRequest) String 

func (r *BulkDeleteRequest) String() string

String returns the on-wire representation of the delete request, concatenated as a single string.

func (*BulkDeleteRequest) Type 

func (r *BulkDeleteRequest) Type(typ string) *BulkDeleteRequest

Type specifies the Elasticsearch type to use for this delete request. If unspecified, the type set on the BulkService will be used.

func (*BulkDeleteRequest) Version 

func (r *BulkDeleteRequest) Version(version int64) *BulkDeleteRequest

Version indicates the version to be deleted as part of an optimistic concurrency model.

func (*BulkDeleteRequest) VersionType 

func (r *BulkDeleteRequest) VersionType(versionType string) *BulkDeleteRequest

VersionType can be "internal" (default), "external", "external_gte", "external_gt", or "force".

type BulkIndexRequest 

type BulkIndexRequest struct {
	BulkableRequest
	// contains filtered or unexported fields
}

Bulk request to add a document to Elasticsearch.

See https://www.elastic.co/guide/en/elasticsearch/reference/1.7/docs-bulk.html for details.

func NewBulkIndexRequest 

func NewBulkIndexRequest() *BulkIndexRequest

NewBulkIndexRequest returns a new BulkIndexRequest. The operation type is "index" by default.

func (*BulkIndexRequest) Doc 

func (r *BulkIndexRequest) Doc(doc interface{}) *BulkIndexRequest

Doc specifies the document to index.

func (*BulkIndexRequest) Id 

func (r *BulkIndexRequest) Id(id string) *BulkIndexRequest

Id specifies the identifier of the document to index.

func (*BulkIndexRequest) Index 

func (r *BulkIndexRequest) Index(index string) *BulkIndexRequest

Index specifies the Elasticsearch index to use for this index request. If unspecified, the index set on the BulkService will be used.

func (*BulkIndexRequest) OpType 

func (r *BulkIndexRequest) OpType(opType string) *BulkIndexRequest

OpType specifies if this request should follow create-only or upsert behavior. This follows the OpType of the standard document index API. See https://www.elastic.co/guide/en/elasticsearch/reference/1.7/docs-index_.html#operation-type for details.

func (*BulkIndexRequest) Parent 

func (r *BulkIndexRequest) Parent(parent string) *BulkIndexRequest

Parent specifies the identifier of the parent document (if available).

func (*BulkIndexRequest) Refresh 

func (r *BulkIndexRequest) Refresh(refresh bool) *BulkIndexRequest

Refresh indicates whether to update the shards immediately after the request has been processed. Newly added documents will appear in search immediately at the cost of slower bulk performance.

func (*BulkIndexRequest) Routing 

func (r *BulkIndexRequest) Routing(routing string) *BulkIndexRequest

Routing specifies a routing value for the request.

func (*BulkIndexRequest) Source 

func (r *BulkIndexRequest) Source() ([]string, error)

Source returns the on-wire representation of the index request, split into an action-and-meta-data line and an (optional) source line. See https://www.elastic.co/guide/en/elasticsearch/reference/1.7/docs-bulk.html for details.

func (*BulkIndexRequest) String 

func (r *BulkIndexRequest) String() string

String returns the on-wire representation of the index request, concatenated as a single string.

func (*BulkIndexRequest) Timestamp 

func (r *BulkIndexRequest) Timestamp(timestamp string) *BulkIndexRequest

Timestamp can be used to index a document with a timestamp. This is deprecated as of 2.0.0-beta2; you should use a normal date field and set its value explicitly.

func (*BulkIndexRequest) Ttl 

func (r *BulkIndexRequest) Ttl(ttl int64) *BulkIndexRequest

Ttl (time to live) sets an expiration date for the document. Expired documents will be expunged automatically. This is deprecated as of 2.0.0-beta2 and will be replaced by a different implementation in a future version.

func (*BulkIndexRequest) Type 

func (r *BulkIndexRequest) Type(typ string) *BulkIndexRequest

Type specifies the Elasticsearch type to use for this index request. If unspecified, the type set on the BulkService will be used.

func (*BulkIndexRequest) Version 

func (r *BulkIndexRequest) Version(version int64) *BulkIndexRequest

Version indicates the version of the document as part of an optimistic concurrency model.

func (*BulkIndexRequest) VersionType 

func (r *BulkIndexRequest) VersionType(versionType string) *BulkIndexRequest

VersionType specifies how versions are created. It can be e.g. internal, external, external_gte, or force.

See https://www.elastic.co/guide/en/elasticsearch/reference/1.7/docs-index_.html#index-versioning for details.

type BulkProcessor 

type BulkProcessor struct {
	// contains filtered or unexported fields
}

BulkProcessor encapsulates a task that accepts bulk requests and orchestrates committing them to Elasticsearch via one or more workers.

BulkProcessor is returned by setting up a BulkProcessorService and calling the Do method.

func (*BulkProcessor) Add 

func (p *BulkProcessor) Add(request BulkableRequest)

Add adds a single request to commit by the BulkProcessorService.

The caller is responsible for setting the index and type on the request.

func (*BulkProcessor) Close 

func (p *BulkProcessor) Close() error

Close stops the bulk processor previously started with Do. If it is already stopped, this is a no-op and nil is returned.

By implementing Close, BulkProcessor implements the io.Closer interface.

func (*BulkProcessor) Flush 

func (p *BulkProcessor) Flush() error

Flush manually asks all workers to commit their outstanding requests. It returns only when all workers acknowledge completion.

func (*BulkProcessor) Start 

func (p *BulkProcessor) Start() error

Start starts the bulk processor. If the processor is already started, nil is returned.

func (*BulkProcessor) Stats 

func (p *BulkProcessor) Stats() BulkProcessorStats

Stats returns the latest bulk processor statistics. Collecting stats must be enabled first by calling Stats(true) on the service that created this processor.

func (*BulkProcessor) Stop 

func (p *BulkProcessor) Stop() error

Stop is an alias for Close.

type BulkProcessorService 

type BulkProcessorService struct {
	// contains filtered or unexported fields
}

BulkProcessorService allows to easily process bulk requests. It allows setting policies when to flush new bulk requests, e.g. based on a number of actions, on the size of the actions, and/or to flush periodically. It also allows to control the number of concurrent bulk requests allowed to be executed in parallel.

BulkProcessorService, by default, commits either every 1000 requests or when the (estimated) size of the bulk requests exceeds 5 MB. However, it does not commit periodically. BulkProcessorService also does retry by default, using an exponential backoff algorithm.

The caller is responsible for setting the index and type on every bulk request added to BulkProcessorService.

BulkProcessorService takes ideas from the BulkProcessor of the Elasticsearch Java API as documented in https://www.elastic.co/guide/en/elasticsearch/client/java-api/current/java-docs-bulk-processor.html.

func NewBulkProcessorService 

func NewBulkProcessorService(client *Client) *BulkProcessorService

NewBulkProcessorService creates a new BulkProcessorService.

func (*BulkProcessorService) After 

func (s *BulkProcessorService) After(fn BulkAfterFunc) *BulkProcessorService

After specifies a function to be executed when bulk requests have been comitted to Elasticsearch. The After callback executes both when the commit was successful as well as on failures.

func (*BulkProcessorService) Before 

func (s *BulkProcessorService) Before(fn BulkBeforeFunc) *BulkProcessorService

Before specifies a function to be executed before bulk requests get comitted to Elasticsearch.

func (*BulkProcessorService) BulkActions 

func (s *BulkProcessorService) BulkActions(bulkActions int) *BulkProcessorService

BulkActions specifies when to flush based on the number of actions currently added. Defaults to 1000 and can be set to -1 to be disabled.

func (*BulkProcessorService) BulkSize 

func (s *BulkProcessorService) BulkSize(bulkSize int) *BulkProcessorService

BulkSize specifies when to flush based on the size (in bytes) of the actions currently added. Defaults to 5 MB and can be set to -1 to be disabled.

func (*BulkProcessorService) Do 

func (s *BulkProcessorService) Do() (*BulkProcessor, error)

Do creates a new BulkProcessor and starts it. Consider the BulkProcessor as a running instance that accepts bulk requests and commits them to Elasticsearch, spreading the work across one or more workers.

You can interoperate with the BulkProcessor returned by Do, e.g. Start and Stop (or Close) it.

Calling Do several times returns new BulkProcessors. You probably don't want to do this. BulkProcessorService implements just a builder pattern.

func (*BulkProcessorService) FlushInterval 

func (s *BulkProcessorService) FlushInterval(interval time.Duration) *BulkProcessorService

FlushInterval specifies when to flush at the end of the given interval. This is disabled by default. If you want the bulk processor to operate completely asynchronously, set both BulkActions and BulkSize to -1 and set the FlushInterval to a meaningful interval.

func (*BulkProcessorService) Name 

func (s *BulkProcessorService) Name(name string) *BulkProcessorService

Name is an optional name to identify this bulk processor.

func (*BulkProcessorService) Stats 

func (s *BulkProcessorService) Stats(wantStats bool) *BulkProcessorService

Stats tells bulk processor to gather stats while running. Use Stats to return the stats. This is disabled by default.

func (*BulkProcessorService) Workers 

func (s *BulkProcessorService) Workers(num int) *BulkProcessorService

Workers is the number of concurrent workers allowed to be executed. Defaults to 1 and must be greater or equal to 1.

type BulkProcessorStats 

type BulkProcessorStats struct {
	Flushed   int64 // number of times the flush interval has been invoked
	Committed int64 // # of times workers committed bulk requests
	Indexed   int64 // # of requests indexed
	Created   int64 // # of requests that ES reported as creates (201)
	Updated   int64 // # of requests that ES reported as updates
	Deleted   int64 // # of requests that ES reported as deletes
	Succeeded int64 // # of requests that ES reported as successful
	Failed    int64 // # of requests that ES reported as failed

	Workers []*BulkProcessorWorkerStats // stats for each worker
}

BulkProcessorStats contains various statistics of a bulk processor while it is running. Use the Stats func to return it while running.

type BulkProcessorWorkerStats 

type BulkProcessorWorkerStats struct {
	Queued       int64         // # of requests queued in this worker
	LastDuration time.Duration // duration of last commit
}

BulkProcessorWorkerStats represents per-worker statistics.

type BulkResponse 

type BulkResponse struct {
	Took   int                            `json:"took,omitempty"`
	Errors bool                           `json:"errors,omitempty"`
	Items  []map[string]*BulkResponseItem `json:"items,omitempty"`
}

BulkResponse is a response to a bulk execution.

Example: 

{
  "took":3,
  "errors":false,
  "items":[{
    "index":{
      "_index":"index1",
      "_type":"tweet",
      "_id":"1",
      "_version":3,
      "status":201
    }
  },{
    "index":{
      "_index":"index2",
      "_type":"tweet",
      "_id":"2",
      "_version":3,
      "status":200
    }
  },{
    "delete":{
      "_index":"index1",
      "_type":"tweet",
      "_id":"1",
      "_version":4,
      "status":200,
      "found":true
    }
  },{
    "update":{
      "_index":"index2",
      "_type":"tweet",
      "_id":"2",
      "_version":4,
      "status":200
    }
  }]
}

func (*BulkResponse) ByAction 

func (r *BulkResponse) ByAction(action string) []*BulkResponseItem

ByAction returns all bulk request results of a certain action, e.g. "index" or "delete".

func (*BulkResponse) ById 

func (r *BulkResponse) ById(id string) []*BulkResponseItem

ById returns all bulk request results of a given document id, regardless of the action ("index", "delete" etc.).

func (*BulkResponse) Created 

func (r *BulkResponse) Created() []*BulkResponseItem

Created returns all bulk request results of "create" actions.

func (*BulkResponse) Deleted 

func (r *BulkResponse) Deleted() []*BulkResponseItem

Deleted returns all bulk request results of "delete" actions.

func (*BulkResponse) Failed 

func (r *BulkResponse) Failed() []*BulkResponseItem

Failed returns those items of a bulk response that have errors, i.e. those that don't have a status code between 200 and 299.

func (*BulkResponse) Indexed 

func (r *BulkResponse) Indexed() []*BulkResponseItem

Indexed returns all bulk request results of "index" actions.

func (*BulkResponse) Succeeded 

func (r *BulkResponse) Succeeded() []*BulkResponseItem

Succeeded returns those items of a bulk response that have no errors, i.e. those have a status code between 200 and 299.

func (*BulkResponse) Updated 

func (r *BulkResponse) Updated() []*BulkResponseItem

Updated returns all bulk request results of "update" actions.

type BulkResponseItem 

type BulkResponseItem struct {
	Index   string `json:"_index,omitempty"`
	Type    string `json:"_type,omitempty"`
	Id      string `json:"_id,omitempty"`
	Version int    `json:"_version,omitempty"`
	Status  int    `json:"status,omitempty"`
	Found   bool   `json:"found,omitempty"`
	Error   string `json:"error,omitempty"`
}

BulkResponseItem is the result of a single bulk request.

type BulkService 

type BulkService struct {
	// contains filtered or unexported fields
}

BulkService allows for batching bulk requests and sending them to Elasticsearch in one roundtrip. Use the Add method with BulkIndexRequest, BulkUpdateRequest, and BulkDeleteRequest to add bulk requests to a batch, then use Do to send them to Elasticsearch.

BulkService will be reset after each Do call. In other words, you can reuse BulkService to send many batches. You do not have to create a new BulkService for each batch.

See https://www.elastic.co/guide/en/elasticsearch/reference/1.7/docs-bulk.html for more details.

func NewBulkService 

func NewBulkService(client *Client) *BulkService

NewBulkService initializes a new BulkService.

func (*BulkService) Add 

func (s *BulkService) Add(requests ...BulkableRequest) *BulkService

Add adds bulkable requests, i.e. BulkIndexRequest, BulkUpdateRequest, and/or BulkDeleteRequest.

func (*BulkService) Do 

func (s *BulkService) Do() (*BulkResponse, error)

Do sends the batched requests to Elasticsearch. Note that, when successful, you can reuse the BulkService for the next batch as the list of bulk requests is cleared on success.

func (*BulkService) EstimatedSizeInBytes 

func (s *BulkService) EstimatedSizeInBytes() int64

EstimatedSizeInBytes returns the estimated size of all bulkable requests added via Add.

func (*BulkService) Index 

func (s *BulkService) Index(index string) *BulkService

Index specifies the index to use for all batches. You may also leave this blank and specify the index in the individual bulk requests.

func (*BulkService) NumberOfActions 

func (s *BulkService) NumberOfActions() int

NumberOfActions returns the number of bulkable requests that need to be sent to Elasticsearch on the next batch.

func (*BulkService) Pretty 

func (s *BulkService) Pretty(pretty bool) *BulkService

Pretty tells Elasticsearch whether to return a formatted JSON response.

func (*BulkService) Refresh 

func (s *BulkService) Refresh(refresh bool) *BulkService

Refresh, when set to true, tells Elasticsearch to make the bulk requests available to search immediately after being processed. Normally, this only happens after a specified refresh interval.

func (*BulkService) Timeout 

func (s *BulkService) Timeout(timeout string) *BulkService

Timeout is a global timeout for processing bulk requests. This is a server-side timeout, i.e. it tells Elasticsearch the time after which it should stop processing.

func (*BulkService) Type 

func (s *BulkService) Type(typ string) *BulkService

Type specifies the type to use for all batches. You may also leave this blank and specify the type in the individual bulk requests.

type BulkUpdateRequest 

type BulkUpdateRequest struct {
	BulkableRequest
	// contains filtered or unexported fields
}

Bulk request to update a document in Elasticsearch.

See https://www.elastic.co/guide/en/elasticsearch/reference/1.7/docs-bulk.html for details.

func NewBulkUpdateRequest 

func NewBulkUpdateRequest() *BulkUpdateRequest

NewBulkUpdateRequest returns a new BulkUpdateRequest.

func (*BulkUpdateRequest) Doc 

func (r *BulkUpdateRequest) Doc(doc interface{}) *BulkUpdateRequest

Doc specifies the updated document.

func (*BulkUpdateRequest) DocAsUpsert 

func (r *BulkUpdateRequest) DocAsUpsert(docAsUpsert bool) *BulkUpdateRequest

DocAsUpsert indicates whether the contents of Doc should be used as the Upsert value.

See https://www.elastic.co/guide/en/elasticsearch/reference/1.7/docs-update.html#_literal_doc_as_upsert_literal for details.

func (*BulkUpdateRequest) Id 

func (r *BulkUpdateRequest) Id(id string) *BulkUpdateRequest

Id specifies the identifier of the document to update.

func (*BulkUpdateRequest) Index 

func (r *BulkUpdateRequest) Index(index string) *BulkUpdateRequest

Index specifies the Elasticsearch index to use for this update request. If unspecified, the index set on the BulkService will be used.

func (*BulkUpdateRequest) Parent 

func (r *BulkUpdateRequest) Parent(parent string) *BulkUpdateRequest

Parent specifies the identifier of the parent document (if available).

func (*BulkUpdateRequest) Refresh 

func (r *BulkUpdateRequest) Refresh(refresh bool) *BulkUpdateRequest

Refresh indicates whether to update the shards immediately after the request has been processed. Updated documents will appear in search immediately at the cost of slower bulk performance.

func (*BulkUpdateRequest) RetryOnConflict 

func (r *BulkUpdateRequest) RetryOnConflict(retryOnConflict int) *BulkUpdateRequest

RetryOnConflict specifies how often to retry in case of a version conflict.

func (*BulkUpdateRequest) Routing 

func (r *BulkUpdateRequest) Routing(routing string) *BulkUpdateRequest

Routing specifies a routing value for the request.

func (*BulkUpdateRequest) Script 

func (r *BulkUpdateRequest) Script(script string) *BulkUpdateRequest

Script specifies the update script.

func (*BulkUpdateRequest) ScriptLang 

func (r *BulkUpdateRequest) ScriptLang(scriptLang string) *BulkUpdateRequest

ScriptLang specifies the language of the update script.

func (*BulkUpdateRequest) ScriptParams 

func (r *BulkUpdateRequest) ScriptParams(params map[string]interface{}) *BulkUpdateRequest

ScriptParams specifies parameters to pass to the update script.

func (*BulkUpdateRequest) ScriptType 

func (r *BulkUpdateRequest) ScriptType(scriptType string) *BulkUpdateRequest

ScriptType specifies the type of the update script.

func (BulkUpdateRequest) Source 

func (r BulkUpdateRequest) Source() ([]string, error)

Source returns the on-wire representation of the update request, split into an action-and-meta-data line and an (optional) source line. See https://www.elastic.co/guide/en/elasticsearch/reference/1.7/docs-bulk.html for details.

func (*BulkUpdateRequest) String 

func (r *BulkUpdateRequest) String() string

String returns the on-wire representation of the update request, concatenated as a single string.

func (*BulkUpdateRequest) Timestamp 

func (r *BulkUpdateRequest) Timestamp(timestamp string) *BulkUpdateRequest

Timestamp specifies a timestamp for the document. This is deprecated as of 2.0.0-beta2.

func (*BulkUpdateRequest) Ttl 

func (r *BulkUpdateRequest) Ttl(ttl int64) *BulkUpdateRequest

Ttl specifies the time to live, and optional expiry time. This is deprecated as of 2.0.0-beta2.

func (*BulkUpdateRequest) Type 

func (r *BulkUpdateRequest) Type(typ string) *BulkUpdateRequest

Type specifies the Elasticsearch type to use for this update request. If unspecified, the type set on the BulkService will be used.

func (*BulkUpdateRequest) Upsert 

func (r *BulkUpdateRequest) Upsert(doc interface{}) *BulkUpdateRequest

Upsert specifies the document to use for upserts. It will be used for create if the original document does not exist.

func (*BulkUpdateRequest) Version 

func (r *BulkUpdateRequest) Version(version int64) *BulkUpdateRequest

Version indicates the version of the document as part of an optimistic concurrency model.

func (*BulkUpdateRequest) VersionType 

func (r *BulkUpdateRequest) VersionType(versionType string) *BulkUpdateRequest

VersionType can be "internal" (default), "external", "external_gte", "external_gt", or "force".

type BulkableRequest 

type BulkableRequest interface {
	fmt.Stringer
	Source() ([]string, error)
}

Generic interface to bulkable requests.

type CandidateGenerator 

type CandidateGenerator interface {
	Type() string
	Source() interface{}
}

type CardinalityAggregation 

type CardinalityAggregation struct {
	// contains filtered or unexported fields
}

CardinalityAggregation is a single-value metrics aggregation that calculates an approximate count of distinct values. Values can be extracted either from specific fields in the document or generated by a script. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-metrics-cardinality-aggregation.html

func NewCardinalityAggregation 

func NewCardinalityAggregation() CardinalityAggregation

func (CardinalityAggregation) Field 

func (a CardinalityAggregation) Field(field string) CardinalityAggregation

func (CardinalityAggregation) Format 

func (a CardinalityAggregation) Format(format string) CardinalityAggregation

func (CardinalityAggregation) Lang 

func (a CardinalityAggregation) Lang(lang string) CardinalityAggregation

func (CardinalityAggregation) Param 

func (a CardinalityAggregation) Param(name string, value interface{}) CardinalityAggregation

func (CardinalityAggregation) PrecisionThreshold 

func (a CardinalityAggregation) PrecisionThreshold(threshold int64) CardinalityAggregation

func (CardinalityAggregation) Rehash 

func (a CardinalityAggregation) Rehash(rehash bool) CardinalityAggregation

func (CardinalityAggregation) Script 

func (a CardinalityAggregation) Script(script string) CardinalityAggregation

func (CardinalityAggregation) ScriptFile 

func (a CardinalityAggregation) ScriptFile(scriptFile string) CardinalityAggregation

func (CardinalityAggregation) Source 

func (a CardinalityAggregation) Source() interface{}

func (CardinalityAggregation) SubAggregation 

func (a CardinalityAggregation) SubAggregation(name string, subAggregation Aggregation) CardinalityAggregation

type ChildrenAggregation 

type ChildrenAggregation struct {
	// contains filtered or unexported fields
}

ChildrenAggregation is a special single bucket aggregation that enables aggregating from buckets on parent document types to buckets on child documents. It is available from 1.4.0.Beta1 upwards. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-children-aggregation.html

func NewChildrenAggregation 

func NewChildrenAggregation() ChildrenAggregation

func (ChildrenAggregation) Source 

func (a ChildrenAggregation) Source() interface{}

func (ChildrenAggregation) SubAggregation 

func (a ChildrenAggregation) SubAggregation(name string, subAggregation Aggregation) ChildrenAggregation

func (ChildrenAggregation) Type 

func (a ChildrenAggregation) Type(typ string) ChildrenAggregation

type ClearScrollResponse 

type ClearScrollResponse struct {
}

ClearScrollResponse is the response of ClearScrollService.Do.

type ClearScrollService 

type ClearScrollService struct {
	// contains filtered or unexported fields
}

ClearScrollService is documented at http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.4/search-request-scroll.html.

func NewClearScrollService 

func NewClearScrollService(client *Client) *ClearScrollService

NewClearScrollService creates a new ClearScrollService.

func (*ClearScrollService) Do 

func (s *ClearScrollService) Do() (*ClearScrollResponse, error)

Do executes the operation.

func (*ClearScrollService) ScrollId 

func (s *ClearScrollService) ScrollId(scrollId ...string) *ClearScrollService

ScrollId is a list of scroll IDs to clear. Use _all to clear all search contexts.

func (*ClearScrollService) Validate 

func (s *ClearScrollService) Validate() error

Validate checks if the operation is valid.

type Client 

type Client struct {
	// contains filtered or unexported fields
}

Client is an Elasticsearch client. Create one by calling NewClient.

func NewClient 

func NewClient(options ...ClientOptionFunc) (*Client, error)

NewClient creates a new client to work with Elasticsearch.

NewClient, by default, is meant to be long-lived and shared across your application. If you need a short-lived client, e.g. for request-scope, consider using NewSimpleClient instead.

The caller can configure the new client by passing configuration options to the func.

Example: 

client, err := elastic.NewClient(
  elastic.SetURL("http://127.0.0.1:9200", "http://127.0.0.1:9201"),
  elastic.SetMaxRetries(10),
  elastic.SetBasicAuth("user", "secret"))

If no URL is configured, Elastic uses DefaultURL by default.

If the sniffer is enabled (the default), the new client then sniffes the cluster via the Nodes Info API (see http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/cluster-nodes-info.html#cluster-nodes-info). It uses the URLs specified by the caller. The caller is responsible to only pass a list of URLs of nodes that belong to the same cluster. This sniffing process is run on startup and periodically. Use SnifferInterval to set the interval between two sniffs (default is 15 minutes). In other words: By default, the client will find new nodes in the cluster and remove those that are no longer available every 15 minutes. Disable the sniffer by passing SetSniff(false) to NewClient.

The list of nodes found in the sniffing process will be used to make connections to the REST API of Elasticsearch. These nodes are also periodically checked in a shorter time frame. This process is called a health check. By default, a health check is done every 60 seconds. You can set a shorter or longer interval by SetHealthcheckInterval. Disabling health checks is not recommended, but can be done by SetHealthcheck(false).

Connections are automatically marked as dead or healthy while making requests to Elasticsearch. When a request fails, Elastic will retry up to a maximum number of retries configured with SetMaxRetries. Retries are disabled by default.

If no HttpClient is configured, then http.DefaultClient is used. You can use your own http.Client with some http.Transport for advanced scenarios.

An error is also returned when some configuration option is invalid or the new client cannot sniff the cluster (if enabled).

func NewSimpleClient 

func NewSimpleClient(options ...ClientOptionFunc) (*Client, error)

NewSimpleClient creates a new short-lived Client that can be used in use cases where you need e.g. one client per request.

While NewClient by default sets up e.g. periodic health checks and sniffing for new nodes in separate goroutines, NewSimpleClient does not and is meant as a simple replacement where you don't need all the heavy lifting of NewClient.

NewSimpleClient does the following by default: First, all health checks are disabled, including timeouts and periodic checks. Second, sniffing is disabled, including timeouts and periodic checks. The number of retries is set to 1. NewSimpleClient also does not start any goroutines.

Notice that you can still override settings by passing additional options, just like with NewClient.

func (*Client) Alias 

func (c *Client) Alias() *AliasService

Alias enables the caller to add and/or remove aliases.

func (*Client) Aliases 

func (c *Client) Aliases() *AliasesService

Aliases returns aliases by index name(s).

func (*Client) Bulk 

func (c *Client) Bulk() *BulkService

Bulk is the entry point to mass insert/update/delete documents.

func (*Client) BulkProcessor 

func (c *Client) BulkProcessor() *BulkProcessorService

BulkProcessor allows setting up a concurrent processor of bulk requests.

func (*Client) ClearScroll 

func (c *Client) ClearScroll() *ClearScrollService

ClearScroll can be used to clear search contexts manually.

func (*Client) CloseIndex 

func (c *Client) CloseIndex(name string) *CloseIndexService

CloseIndex closes an index.

func (*Client) ClusterHealth 

func (c *Client) ClusterHealth() *ClusterHealthService

ClusterHealth retrieves the health of the cluster.

func (*Client) ClusterState 

func (c *Client) ClusterState() *ClusterStateService

ClusterState retrieves the state of the cluster.

func (*Client) ClusterStats 

func (c *Client) ClusterStats() *ClusterStatsService

ClusterStats retrieves cluster statistics.

func (*Client) Count 

func (c *Client) Count(indices ...string) *CountService

Count documents.

func (*Client) CreateIndex 

func (c *Client) CreateIndex(name string) *CreateIndexService

CreateIndex returns a service to create a new index.

func (*Client) Delete 

func (c *Client) Delete() *DeleteService

Delete a document.

func (*Client) DeleteByQuery 

func (c *Client) DeleteByQuery() *DeleteByQueryService

DeleteByQuery deletes documents as found by a query.

func (*Client) DeleteIndex 

func (c *Client) DeleteIndex(name string) *DeleteIndexService

DeleteIndex returns a service to delete an index.

func (*Client) DeleteMapping 

func (c *Client) DeleteMapping() *DeleteMappingService

DeleteMapping deletes a mapping.

func (*Client) DeleteTemplate 

func (c *Client) DeleteTemplate() *DeleteTemplateService

DeleteTemplate deletes a search template. Use IndexXXXTemplate funcs to manage index templates.

func (*Client) DeleteWarmer 

func (c *Client) DeleteWarmer() *IndicesDeleteWarmerService

DeleteWarmer deletes one or more warmers.

func (*Client) ElasticsearchVersion 

func (c *Client) ElasticsearchVersion(url string) (string, error)

ElasticsearchVersion returns the version number of Elasticsearch running on the given URL.

func (*Client) Exists 

func (c *Client) Exists() *ExistsService

Exists checks if a document exists.

func (*Client) Explain 

func (c *Client) Explain(index, typ, id string) *ExplainService

Explain computes a score explanation for a query and a specific document.

func (*Client) Flush 

func (c *Client) Flush(indices ...string) *FlushService

Flush asks Elasticsearch to free memory from the index and flush data to disk.

func (*Client) Get 

func (c *Client) Get() *GetService

Get a document.

func (*Client) GetMapping 

func (c *Client) GetMapping() *GetMappingService

GetMapping gets a mapping.

func (*Client) GetTemplate 

func (c *Client) GetTemplate() *GetTemplateService

GetTemplate gets a search template. Use IndexXXXTemplate funcs to manage index templates.

func (*Client) GetWarmer 

func (c *Client) GetWarmer() *IndicesGetWarmerService

GetWarmer gets one or more warmers by name.

func (*Client) Index 

func (c *Client) Index() *IndexService

Index a document.

func (*Client) IndexDeleteTemplate 

func (c *Client) IndexDeleteTemplate(name string) *IndicesDeleteTemplateService

IndexDeleteTemplate deletes an index template. Use XXXTemplate funcs to manage search templates.

func (*Client) IndexExists 

func (c *Client) IndexExists(name string) *IndexExistsService

IndexExists allows to check if an index exists.

func (*Client) IndexGet 

func (c *Client) IndexGet() *IndicesGetService

IndexGet retrieves information about one or more indices. IndexGet is only available for Elasticsearch 1.4 or later.

func (*Client) IndexGetSettings 

func (c *Client) IndexGetSettings(indices ...string) *IndicesGetSettingsService

IndexGetSettings retrieves settings of all, one or more indices.

func (*Client) IndexGetTemplate 

func (c *Client) IndexGetTemplate(names ...string) *IndicesGetTemplateService

IndexGetTemplate gets an index template. Use XXXTemplate funcs to manage search templates.

func (*Client) IndexNames 

func (c *Client) IndexNames() ([]string, error)

IndexNames returns the names of all indices in the cluster.

func (*Client) IndexPutSettings 

func (c *Client) IndexPutSettings(indices ...string) *IndicesPutSettingsService

IndexPutSettings sets settings for all, one or more indices.

func (*Client) IndexPutTemplate 

func (c *Client) IndexPutTemplate(name string) *IndicesPutTemplateService

IndexPutTemplate creates or updates an index template. Use XXXTemplate funcs to manage search templates.

func (*Client) IndexStats 

func (c *Client) IndexStats(indices ...string) *IndicesStatsService

IndexStats provides statistics on different operations happining in one or more indices.

func (*Client) IndexTemplateExists 

func (c *Client) IndexTemplateExists(name string) *IndicesExistsTemplateService

IndexTemplateExists gets check if an index template exists. Use XXXTemplate funcs to manage search templates.

func (*Client) IsRunning 

func (c *Client) IsRunning() bool

IsRunning returns true if the background processes of the client are running, false otherwise.

func (*Client) MultiGet 

func (c *Client) MultiGet() *MultiGetService

MultiGet retrieves multiple documents in one roundtrip.

func (*Client) MultiSearch 

func (c *Client) MultiSearch() *MultiSearchService

MultiSearch is the entry point for multi searches.

func (*Client) NodesInfo 

func (c *Client) NodesInfo() *NodesInfoService

NodesInfo retrieves one or more or all of the cluster nodes information.

func (*Client) OpenIndex 

func (c *Client) OpenIndex(name string) *OpenIndexService

OpenIndex opens an index.

func (*Client) Optimize 

func (c *Client) Optimize(indices ...string) *OptimizeService

Optimize asks Elasticsearch to optimize one or more indices.

func (*Client) Percolate 

func (c *Client) Percolate() *PercolateService

Percolate allows to send a document and return matching queries. See http://www.elastic.co/guide/en/elasticsearch/reference/current/search-percolate.html.

func (*Client) PerformRequest 

func (c *Client) PerformRequest(method, path string, params url.Values, body interface{}) (*Response, error)

PerformRequest does a HTTP request to Elasticsearch. It returns a response and an error on failure.

func (*Client) Ping 

func (c *Client) Ping() *PingService

Ping checks if a given node in a cluster exists and (optionally) returns some basic information about the Elasticsearch server, e.g. the Elasticsearch version number.

func (*Client) PutMapping 

func (c *Client) PutMapping() *PutMappingService

PutMapping registers a mapping.

func (*Client) PutTemplate 

func (c *Client) PutTemplate() *PutTemplateService

PutTemplate creates or updates a search template. Use IndexXXXTemplate funcs to manage index templates.

func (*Client) PutWarmer 

func (c *Client) PutWarmer() *IndicesPutWarmerService

PutWarmer registers a warmer.

func (*Client) Refresh 

func (c *Client) Refresh(indices ...string) *RefreshService

Refresh asks Elasticsearch to refresh one or more indices.

func (*Client) Reindex 

func (c *Client) Reindex(sourceIndex, targetIndex string) *Reindexer

Reindex returns a service that will reindex documents from a source index into a target index. See http://www.elastic.co/guide/en/elasticsearch/guide/current/reindex.html for more information about reindexing.

func (*Client) Scan 

func (c *Client) Scan(indices ...string) *ScanService

Scan through documents. Use this to iterate inside a server process where the results will be processed without returning them to a client.

func (*Client) Scroll 

func (c *Client) Scroll(indices ...string) *ScrollService

Scroll through documents. Use this to efficiently scroll through results while returning the results to a client. Use Scan when you don't need to return requests to a client (i.e. not paginating via request/response).

func (*Client) Search 

func (c *Client) Search(indices ...string) *SearchService

Search is the entry point for searches.

func (*Client) Start 

func (c *Client) Start()

Start starts the background processes like sniffing the cluster and periodic health checks. You don't need to run Start when creating a client with NewClient; the background processes are run by default.

If the background processes are already running, this is a no-op.

func (*Client) Stop 

func (c *Client) Stop()

Stop stops the background processes that the client is running, i.e. sniffing the cluster periodically and running health checks on the nodes.

If the background processes are not running, this is a no-op.

func (*Client) String 

func (c *Client) String() string

String returns a string representation of the client status.

func (*Client) Suggest 

func (c *Client) Suggest(indices ...string) *SuggestService

Suggest returns a service to return suggestions.

func (*Client) TermVector 

func (c *Client) TermVector(index, typ string) *TermvectorService

TermVector returns information and statistics on terms in the fields of a particular document.

func (*Client) TypeExists 

func (c *Client) TypeExists() *IndicesExistsTypeService

TypeExists allows to check if one or more types exist in one or more indices.

func (*Client) Update 

func (c *Client) Update() *UpdateService

Update a document.

func (*Client) WaitForGreenStatus 

func (c *Client) WaitForGreenStatus(timeout string) error

WaitForGreenStatus waits for the cluster to have the "green" status. See WaitForStatus for more details.

func (*Client) WaitForStatus 

func (c *Client) WaitForStatus(status string, timeout string) error

WaitForStatus waits for the cluster to have the given status. This is a shortcut method for the ClusterHealth service.

WaitForStatus waits for the specified timeout, e.g. "10s". If the cluster will have the given state within the timeout, nil is returned. If the request timed out, ErrTimeout is returned.

func (*Client) WaitForYellowStatus 

func (c *Client) WaitForYellowStatus(timeout string) error

WaitForYellowStatus waits for the cluster to have the "yellow" status. See WaitForStatus for more details.

type ClientOptionFunc 

type ClientOptionFunc func(*Client) error

ClientOptionFunc is a function that configures a Client. It is used in NewClient.

func SetBasicAuth 

func SetBasicAuth(username, password string) ClientOptionFunc

SetBasicAuth can be used to specify the HTTP Basic Auth credentials to use when making HTTP requests to Elasticsearch.

func SetDecoder 

func SetDecoder(decoder Decoder) ClientOptionFunc

SetDecoder sets the Decoder to use when decoding data from Elasticsearch. DefaultDecoder is used by default.

func SetErrorLog 

func SetErrorLog(logger Logger) ClientOptionFunc

SetErrorLog sets the logger for critical messages like nodes joining or leaving the cluster or failing requests. It is nil by default.

func SetGzip 

func SetGzip(enabled bool) ClientOptionFunc

SetGzip enables or disables gzip compression (disabled by default).

func SetHealthcheck 

func SetHealthcheck(enabled bool) ClientOptionFunc

SetHealthcheck enables or disables healthchecks (enabled by default).

func SetHealthcheckInterval 

func SetHealthcheckInterval(interval time.Duration) ClientOptionFunc

SetHealthcheckInterval sets the interval between two health checks. The default interval is 60 seconds.

func SetHealthcheckTimeout 

func SetHealthcheckTimeout(timeout time.Duration) ClientOptionFunc

SetHealthcheckTimeout sets the timeout for periodic health checks. The default timeout is 1 second (see DefaultHealthcheckTimeout). Notice that a different (usually larger) timeout is used for the initial healthcheck, which is initiated while creating a new client. The startup timeout can be modified with SetHealthcheckTimeoutStartup.

func SetHealthcheckTimeoutStartup 

func SetHealthcheckTimeoutStartup(timeout time.Duration) ClientOptionFunc

SetHealthcheckTimeoutStartup sets the timeout for the initial health check. The default timeout is 5 seconds (see DefaultHealthcheckTimeoutStartup). Notice that timeouts for subsequent health checks can be modified with SetHealthcheckTimeout.

func SetHttpClient 

func SetHttpClient(httpClient *http.Client) ClientOptionFunc

SetHttpClient can be used to specify the http.Client to use when making HTTP requests to Elasticsearch.

func SetInfoLog 

func SetInfoLog(logger Logger) ClientOptionFunc

SetInfoLog sets the logger for informational messages, e.g. requests and their response times. It is nil by default.

func SetMaxRetries 

func SetMaxRetries(maxRetries int) ClientOptionFunc

SetMaxRetries sets the maximum number of retries before giving up when performing a HTTP request to Elasticsearch.

func SetScheme 

func SetScheme(scheme string) ClientOptionFunc

SetScheme sets the HTTP scheme to look for when sniffing (http or https). This is http by default.

func SetSendGetBodyAs 

func SetSendGetBodyAs(httpMethod string) ClientOptionFunc

SendGetBodyAs specifies the HTTP method to use when sending a GET request with a body. It is GET by default.

func SetSniff 

func SetSniff(enabled bool) ClientOptionFunc

SetSniff enables or disables the sniffer (enabled by default).

func SetSnifferInterval 

func SetSnifferInterval(interval time.Duration) ClientOptionFunc

SetSnifferInterval sets the interval between two sniffing processes. The default interval is 15 minutes.

func SetSnifferTimeout 

func SetSnifferTimeout(timeout time.Duration) ClientOptionFunc

SetSnifferTimeout sets the timeout for the sniffer that finds the nodes in a cluster. The default is 2 seconds. Notice that the timeout used when creating a new client on startup is usually greater and can be set with SetSnifferTimeoutStartup.

func SetSnifferTimeoutStartup 

func SetSnifferTimeoutStartup(timeout time.Duration) ClientOptionFunc

SetSnifferTimeoutStartup sets the timeout for the sniffer that is used when creating a new client. The default is 5 seconds. Notice that the timeout being used for subsequent sniffing processes is set with SetSnifferTimeout.

func SetTraceLog 

func SetTraceLog(logger Logger) ClientOptionFunc

SetTraceLog specifies the log.Logger to use for output of HTTP requests and responses which is helpful during debugging. It is nil by default.

func SetURL 

func SetURL(urls ...string) ClientOptionFunc

SetURL defines the URL endpoints of the Elasticsearch nodes. Notice that when sniffing is enabled, these URLs are used to initially sniff the cluster on startup.

type CloseIndexResponse 

type CloseIndexResponse struct {
	Acknowledged bool `json:"acknowledged"`
}

CloseIndexResponse is the response of CloseIndexService.Do.

type CloseIndexService 

type CloseIndexService struct {
	// contains filtered or unexported fields
}

CloseIndexService closes an index. See documentation at http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.4/indices-open-close.html.

func NewCloseIndexService 

func NewCloseIndexService(client *Client) *CloseIndexService

NewCloseIndexService creates a new CloseIndexService.

func (*CloseIndexService) AllowNoIndices 

func (s *CloseIndexService) AllowNoIndices(allowNoIndices bool) *CloseIndexService

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 (*CloseIndexService) Do 

func (s *CloseIndexService) Do() (*CloseIndexResponse, error)

Do executes the operation.

func (*CloseIndexService) ExpandWildcards 

func (s *CloseIndexService) ExpandWildcards(expandWildcards string) *CloseIndexService

ExpandWildcards indicates whether to expand wildcard expression to concrete indices that are open, closed or both.

func (*CloseIndexService) IgnoreUnavailable 

func (s *CloseIndexService) IgnoreUnavailable(ignoreUnavailable bool) *CloseIndexService

IgnoreUnavailable indicates whether specified concrete indices should be ignored when unavailable (missing or closed).

func (*CloseIndexService) Index 

func (s *CloseIndexService) Index(index string) *CloseIndexService

Index is the name of the index.

func (*CloseIndexService) MasterTimeout 

func (s *CloseIndexService) MasterTimeout(masterTimeout string) *CloseIndexService

MasterTimeout specifies the timeout for connection to master.

func (*CloseIndexService) Timeout 

func (s *CloseIndexService) Timeout(timeout string) *CloseIndexService

Timeout is an explicit operation timeout.

func (*CloseIndexService) Validate 

func (s *CloseIndexService) Validate() error

Validate checks if the operation is valid.

type ClusterHealthResponse 

type ClusterHealthResponse struct {
	ClusterName          string `json:"cluster_name"`
	Status               string `json:"status"`
	TimedOut             bool   `json:"timed_out"`
	NumberOfNodes        int    `json:"number_of_nodes"`
	NumberOfDataNodes    int    `json:"number_of_data_nodes"`
	ActivePrimaryShards  int    `json:"active_primary_shards"`
	ActiveShards         int    `json:"active_shards"`
	RelocatingShards     int    `json:"relocating_shards"`
	InitializingShards   int    `json:"initializing_shards"`
	UnassignedShards     int    `json:"unassigned_shards"`
	NumberOfPendingTasks int    `json:"number_of_pending_tasks"`
}

ClusterHealthResponse is the response of ClusterHealthService.Do.

type ClusterHealthService 

type ClusterHealthService struct {
	// contains filtered or unexported fields
}

ClusterHealthService allows to get the status of the cluster. It is documented at http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.4/cluster-health.html.

Example 
package main

import (
	"fmt"

	elastic "gopkg.in/olivere/elastic.v2"
)

func main() {
	client, err := elastic.NewClient()
	if err != nil {
		panic(err)
	}

	// Get cluster health
	res, err := client.ClusterHealth().Index("twitter").Do()
	if err != nil {
		panic(err)
	}
	if res == nil {
		panic(err)
	}
	fmt.Printf("Cluster status is %q\n", res.Status)
}

Output:

func NewClusterHealthService 

func NewClusterHealthService(client *Client) *ClusterHealthService

NewClusterHealthService creates a new ClusterHealthService.

func (*ClusterHealthService) Do 

func (s *ClusterHealthService) Do() (*ClusterHealthResponse, error)

Do executes the operation.

func (*ClusterHealthService) Index 

func (s *ClusterHealthService) Index(index string) *ClusterHealthService

Index limits the information returned to a specific index.

func (*ClusterHealthService) Indices 

func (s *ClusterHealthService) Indices(indices ...string) *ClusterHealthService

Indices limits the information returned to specific indices.

func (*ClusterHealthService) Level 

func (s *ClusterHealthService) Level(level string) *ClusterHealthService

Level specifies the level of detail for returned information.

func (*ClusterHealthService) Local 

func (s *ClusterHealthService) Local(local bool) *ClusterHealthService

Local indicates whether to return local information. If it is true, we do not retrieve the state from master node (default: false).

func (*ClusterHealthService) MasterTimeout 

func (s *ClusterHealthService) MasterTimeout(masterTimeout string) *ClusterHealthService

MasterTimeout specifies an explicit operation timeout for connection to master node.

func (*ClusterHealthService) Timeout 

func (s *ClusterHealthService) Timeout(timeout string) *ClusterHealthService

Timeout specifies an explicit operation timeout.

func (*ClusterHealthService) Validate 

func (s *ClusterHealthService) Validate() error

Validate checks if the operation is valid.

func (*ClusterHealthService) WaitForActiveShards 

func (s *ClusterHealthService) WaitForActiveShards(waitForActiveShards int) *ClusterHealthService

WaitForActiveShards can be used to wait until the specified number of shards are active.

func (*ClusterHealthService) WaitForNodes 

func (s *ClusterHealthService) WaitForNodes(waitForNodes string) *ClusterHealthService

WaitForNodes can be used to wait until the specified number of nodes are available.

func (*ClusterHealthService) WaitForRelocatingShards 

func (s *ClusterHealthService) WaitForRelocatingShards(waitForRelocatingShards int) *ClusterHealthService

WaitForRelocatingShards can be used to wait until the specified number of relocating shards is finished.

func (*ClusterHealthService) WaitForStatus 

func (s *ClusterHealthService) WaitForStatus(waitForStatus string) *ClusterHealthService

WaitForStatus can be used to wait until the cluster is in a specific state. Valid values are: green, yellow, or red.

type ClusterStateMetadata 

type ClusterStateMetadata struct {
	Templates    map[string]interface{} `json:"templates"`
	Indices      map[string]interface{} `json:"indices"`
	Repositories map[string]interface{} `json:"repositories"`
}

type ClusterStateNode 

type ClusterStateNode struct {
	Name             string                 `json:"name"`
	TransportAddress string                 `json:"transport_address"`
	Attributes       map[string]interface{} `json:"attributes"`

	// TODO(oe) are these still valid?
	State          string  `json:"state"`
	Primary        bool    `json:"primary"`
	Node           string  `json:"node"`
	RelocatingNode *string `json:"relocating_node"`
	Shard          int     `json:"shard"`
	Index          string  `json:"index"`
}

type ClusterStateResponse 

type ClusterStateResponse struct {
	ClusterName  string                               `json:"cluster_name"`
	Version      int                                  `json:"version"`
	MasterNode   string                               `json:"master_node"`
	Blocks       map[string]interface{}               `json:"blocks"`
	Nodes        map[string]*ClusterStateNode         `json:"nodes"`
	Metadata     *ClusterStateMetadata                `json:"metadata"`
	RoutingTable map[string]*ClusterStateRoutingTable `json:"routing_table"`
	RoutingNodes *ClusterStateRoutingNode             `json:"routing_nodes"`
	Allocations  []interface{}                        `json:"allocations"`
	Customs      map[string]interface{}               `json:"customs"`
}

ClusterStateResponse is the response of ClusterStateService.Do.

type ClusterStateRoutingNode 

type ClusterStateRoutingNode struct {
	Unassigned []interface{}          `json:"unassigned"`
	Nodes      map[string]interface{} `json:"nodes"`
}

type ClusterStateRoutingTable 

type ClusterStateRoutingTable struct {
	Indices map[string]interface{} `json:"indices"`
}

type ClusterStateService 

type ClusterStateService struct {
	// contains filtered or unexported fields
}

ClusterStateService returns the state of the cluster. It is documented at http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.4/cluster-state.html.

Example 
package main

import (
	"fmt"

	elastic "gopkg.in/olivere/elastic.v2"
)

func main() {
	client, err := elastic.NewClient()
	if err != nil {
		panic(err)
	}

	// Get cluster state
	res, err := client.ClusterState().Metric("version").Do()
	if err != nil {
		panic(err)
	}
	fmt.Printf("Cluster %q has version %d", res.ClusterName, res.Version)
}

Output:

func NewClusterStateService 

func NewClusterStateService(client *Client) *ClusterStateService

NewClusterStateService creates a new ClusterStateService.

func (*ClusterStateService) Do 

func (s *ClusterStateService) Do() (*ClusterStateResponse, error)

Do executes the operation.

func (*ClusterStateService) FlatSettings 

func (s *ClusterStateService) FlatSettings(flatSettings bool) *ClusterStateService

FlatSettings indicates whether to return settings in flat format (default: false).

func (*ClusterStateService) Index 

func (s *ClusterStateService) Index(index string) *ClusterStateService

Index the name of the index. Use _all or an empty string to perform the operation on all indices.

func (*ClusterStateService) Indices 

func (s *ClusterStateService) Indices(indices ...string) *ClusterStateService

Indices is a list of index names. Use _all or an empty string to perform the operation on all indices.

func (*ClusterStateService) Local 

func (s *ClusterStateService) Local(local bool) *ClusterStateService

Local indicates whether to return local information. If it is true, we do not retrieve the state from master node (default: false).

func (*ClusterStateService) MasterTimeout 

func (s *ClusterStateService) MasterTimeout(masterTimeout string) *ClusterStateService

MasterTimeout specifies the timeout for connection to master.

func (*ClusterStateService) Metric 

func (s *ClusterStateService) Metric(metric string) *ClusterStateService

Metric limits the information returned to the specified metric. It can be one of: version, master_node, nodes, routing_table, metadata, blocks, or customs.

func (*ClusterStateService) Metrics 

func (s *ClusterStateService) Metrics(metrics ...string) *ClusterStateService

Metrics limits the information returned to the specified metrics. It can be any of: version, master_node, nodes, routing_table, metadata, blocks, or customs.

func (*ClusterStateService) Validate 

func (s *ClusterStateService) Validate() error

Validate checks if the operation is valid.

type ClusterStatsIndices 

type ClusterStatsIndices struct {
	Count       int                             `json:"count"`
	Shards      *ClusterStatsIndicesShards      `json:"shards"`
	Docs        *ClusterStatsIndicesDocs        `json:"docs"`
	Store       *ClusterStatsIndicesStore       `json:"store"`
	FieldData   *ClusterStatsIndicesFieldData   `json:"fielddata"`
	FilterCache *ClusterStatsIndicesFilterCache `json:"filter_cache"`
	IdCache     *ClusterStatsIndicesIdCache     `json:"id_cache"`
	Completion  *ClusterStatsIndicesCompletion  `json:"completion"`
	Segments    *ClusterStatsIndicesSegments    `json:"segments"`
	Percolate   *ClusterStatsIndicesPercolate   `json:"percolate"`
}

type ClusterStatsIndicesCompletion 

type ClusterStatsIndicesCompletion struct {
	Size        string `json:"size"` // e.g. "61.3kb"
	SizeInBytes int64  `json:"size_in_bytes"`
	Fields      map[string]struct {
		Size        string `json:"size"` // e.g. "61.3kb"
		SizeInBytes int64  `json:"size_in_bytes"`
	} `json:"fields"`
}

type ClusterStatsIndicesDocs 

type ClusterStatsIndicesDocs struct {
	Count   int `json:"count"`
	Deleted int `json:"deleted"`
}

type ClusterStatsIndicesFieldData 

type ClusterStatsIndicesFieldData struct {
	MemorySize        string `json:"memory_size"` // e.g. "61.3kb"
	MemorySizeInBytes int64  `json:"memory_size_in_bytes"`
	Evictions         int64  `json:"evictions"`
	Fields            map[string]struct {
		MemorySize        string `json:"memory_size"` // e.g. "61.3kb"
		MemorySizeInBytes int64  `json:"memory_size_in_bytes"`
	} `json:"fields"`
}

type ClusterStatsIndicesFilterCache 

type ClusterStatsIndicesFilterCache struct {
	MemorySize        string `json:"memory_size"` // e.g. "61.3kb"
	MemorySizeInBytes int64  `json:"memory_size_in_bytes"`
	Evictions         int64  `json:"evictions"`
}

type ClusterStatsIndicesIdCache 

type ClusterStatsIndicesIdCache struct {
	MemorySize        string `json:"memory_size"` // e.g. "61.3kb"
	MemorySizeInBytes int64  `json:"memory_size_in_bytes"`
}

type ClusterStatsIndicesPercolate 

type ClusterStatsIndicesPercolate struct {
	Total int64 `json:"total"`
	// TODO(oe) The JSON tag here is wrong as of ES 1.5.2 it seems
	Time              string `json:"get_time"` // e.g. "1s"
	TimeInBytes       int64  `json:"time_in_millis"`
	Current           int64  `json:"current"`
	MemorySize        string `json:"memory_size"` // e.g. "61.3kb"
	MemorySizeInBytes int64  `json:"memory_sitze_in_bytes"`
	Queries           int64  `json:"queries"`
}

type ClusterStatsIndicesSegments 

type ClusterStatsIndicesSegments struct {
	Count                       int64  `json:"count"`
	Memory                      string `json:"memory"` // e.g. "61.3kb"
	MemoryInBytes               int64  `json:"memory_in_bytes"`
	IndexWriterMemory           string `json:"index_writer_memory"` // e.g. "61.3kb"
	IndexWriterMemoryInBytes    int64  `json:"index_writer_memory_in_bytes"`
	IndexWriterMaxMemory        string `json:"index_writer_max_memory"` // e.g. "61.3kb"
	IndexWriterMaxMemoryInBytes int64  `json:"index_writer_max_memory_in_bytes"`
	VersionMapMemory            string `json:"version_map_memory"` // e.g. "61.3kb"
	VersionMapMemoryInBytes     int64  `json:"version_map_memory_in_bytes"`
	FixedBitSet                 string `json:"fixed_bit_set"` // e.g. "61.3kb"
	FixedBitSetInBytes          int64  `json:"fixed_bit_set_memory_in_bytes"`
}

type ClusterStatsIndicesShards 

type ClusterStatsIndicesShards struct {
	Total       int                             `json:"total"`
	Primaries   int                             `json:"primaries"`
	Replication float64                         `json:"replication"`
	Index       *ClusterStatsIndicesShardsIndex `json:"index"`
}

type ClusterStatsIndicesShardsIndex 

type ClusterStatsIndicesShardsIndex struct {
	Shards      *ClusterStatsIndicesShardsIndexIntMinMax     `json:"shards"`
	Primaries   *ClusterStatsIndicesShardsIndexIntMinMax     `json:"primaries"`
	Replication *ClusterStatsIndicesShardsIndexFloat64MinMax `json:"replication"`
}

type ClusterStatsIndicesShardsIndexFloat64MinMax 

type ClusterStatsIndicesShardsIndexFloat64MinMax struct {
	Min float64 `json:"min"`
	Max float64 `json:"max"`
	Avg float64 `json:"avg"`
}

type ClusterStatsIndicesShardsIndexIntMinMax 

type ClusterStatsIndicesShardsIndexIntMinMax struct {
	Min int     `json:"min"`
	Max int     `json:"max"`
	Avg float64 `json:"avg"`
}

type ClusterStatsIndicesStore 

type ClusterStatsIndicesStore struct {
	Size                 string `json:"size"` // e.g. "5.3gb"
	SizeInBytes          int64  `json:"size_in_bytes"`
	ThrottleTime         string `json:"throttle_time"` // e.g. "0s"
	ThrottleTimeInMillis int64  `json:"throttle_time_in_millis"`
}

type ClusterStatsNodes 

type ClusterStatsNodes struct {
	Count    *ClusterStatsNodesCount        `json:"count"`
	Versions []string                       `json:"versions"`
	OS       *ClusterStatsNodesOsStats      `json:"os"`
	Process  *ClusterStatsNodesProcessStats `json:"process"`
	JVM      *ClusterStatsNodesJvmStats     `json:"jvm"`
	FS       *ClusterStatsNodesFsStats      `json:"fs"`
	Plugins  []*ClusterStatsNodesPlugin     `json:"plugins"`
}

type ClusterStatsNodesCount 

type ClusterStatsNodesCount struct {
	Total      int `json:"total"`
	MasterOnly int `json:"master_only"`
	DataOnly   int `json:"data_only"`
	MasterData int `json:"master_data"`
	Client     int `json:"client"`
}

type ClusterStatsNodesFsStats 

type ClusterStatsNodesFsStats struct {
	Path                 string `json:"path"`
	Mount                string `json:"mount"`
	Dev                  string `json:"dev"`
	Total                string `json:"total"` // e.g. "930.7gb"`
	TotalInBytes         int64  `json:"total_in_bytes"`
	Free                 string `json:"free"` // e.g. "930.7gb"`
	FreeInBytes          int64  `json:"free_in_bytes"`
	Available            string `json:"available"` // e.g. "930.7gb"`
	AvailableInBytes     int64  `json:"available_in_bytes"`
	DiskReads            int64  `json:"disk_reads"`
	DiskWrites           int64  `json:"disk_writes"`
	DiskIOOp             int64  `json:"disk_io_op"`
	DiskReadSize         string `json:"disk_read_size"` // e.g. "0b"`
	DiskReadSizeInBytes  int64  `json:"disk_read_size_in_bytes"`
	DiskWriteSize        string `json:"disk_write_size"` // e.g. "0b"`
	DiskWriteSizeInBytes int64  `json:"disk_write_size_in_bytes"`
	DiskIOSize           string `json:"disk_io_size"` // e.g. "0b"`
	DiskIOSizeInBytes    int64  `json:"disk_io_size_in_bytes"`
	DiskQueue            string `json:"disk_queue"`
	DiskServiceTime      string `json:"disk_service_time"`
}

type ClusterStatsNodesJvmStats 

type ClusterStatsNodesJvmStats struct {
	MaxUptime         string                              `json:"max_uptime"` // e.g. "5h"
	MaxUptimeInMillis int64                               `json:"max_uptime_in_millis"`
	Versions          []*ClusterStatsNodesJvmStatsVersion `json:"versions"`
	Mem               *ClusterStatsNodesJvmStatsMem       `json:"mem"`
	Threads           int64                               `json:"threads"`
}

type ClusterStatsNodesJvmStatsMem 

type ClusterStatsNodesJvmStatsMem struct {
	HeapUsed        string `json:"heap_used"`
	HeapUsedInBytes int64  `json:"heap_used_in_bytes"`
	HeapMax         string `json:"heap_max"`
	HeapMaxInBytes  int64  `json:"heap_max_in_bytes"`
}

type ClusterStatsNodesJvmStatsVersion 

type ClusterStatsNodesJvmStatsVersion struct {
	Version   string `json:"version"`    // e.g. "1.8.0_45"
	VMName    string `json:"vm_name"`    // e.g. "Java HotSpot(TM) 64-Bit Server VM"
	VMVersion string `json:"vm_version"` // e.g. "25.45-b02"
	VMVendor  string `json:"vm_vendor"`  // e.g. "Oracle Corporation"
	Count     int    `json:"count"`
}

type ClusterStatsNodesOsStats 

type ClusterStatsNodesOsStats struct {
	AvailableProcessors int                            `json:"available_processors"`
	Mem                 *ClusterStatsNodesOsStatsMem   `json:"mem"`
	CPU                 []*ClusterStatsNodesOsStatsCPU `json:"cpu"`
}

type ClusterStatsNodesOsStatsCPU 

type ClusterStatsNodesOsStatsCPU struct {
	Vendor           string `json:"vendor"`
	Model            string `json:"model"`
	MHz              int    `json:"mhz"`
	TotalCores       int    `json:"total_cores"`
	TotalSockets     int    `json:"total_sockets"`
	CoresPerSocket   int    `json:"cores_per_socket"`
	CacheSize        string `json:"cache_size"` // e.g. "256b"
	CacheSizeInBytes int64  `json:"cache_size_in_bytes"`
	Count            int    `json:"count"`
}

type ClusterStatsNodesOsStatsMem 

type ClusterStatsNodesOsStatsMem struct {
	Total        string `json:"total"` // e.g. "16gb"
	TotalInBytes int64  `json:"total_in_bytes"`
}

type ClusterStatsNodesPlugin 

type ClusterStatsNodesPlugin struct {
	Name        string `json:"name"`
	Version     string `json:"version"`
	Description string `json:"description"`
	URL         string `json:"url"`
	JVM         bool   `json:"jvm"`
	Site        bool   `json:"site"`
}

type ClusterStatsNodesProcessStats 

type ClusterStatsNodesProcessStats struct {
	CPU                 *ClusterStatsNodesProcessStatsCPU                 `json:"cpu"`
	OpenFileDescriptors *ClusterStatsNodesProcessStatsOpenFileDescriptors `json:"open_file_descriptors"`
}

type ClusterStatsNodesProcessStatsCPU 

type ClusterStatsNodesProcessStatsCPU struct {
	Percent float64 `json:"percent"`
}

type ClusterStatsNodesProcessStatsOpenFileDescriptors 

type ClusterStatsNodesProcessStatsOpenFileDescriptors struct {
	Min int64 `json:"min"`
	Max int64 `json:"max"`
	Avg int64 `json:"avg"`
}

type ClusterStatsResponse 

type ClusterStatsResponse struct {
	Timestamp   int64                `json:"timestamp"`
	ClusterName string               `json:"cluster_name"`
	ClusterUUID string               `json:"uuid"`
	Status      string               `json:"status"`
	Indices     *ClusterStatsIndices `json:"indices"`
	Nodes       *ClusterStatsNodes   `json:"nodes"`
}

ClusterStatsResponse is the response of ClusterStatsService.Do.

type ClusterStatsService 

type ClusterStatsService struct {
	// contains filtered or unexported fields
}

ClusterStatsService is documented at http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.4/cluster-stats.html.

func NewClusterStatsService 

func NewClusterStatsService(client *Client) *ClusterStatsService

NewClusterStatsService creates a new ClusterStatsService.

func (*ClusterStatsService) Do 

func (s *ClusterStatsService) Do() (*ClusterStatsResponse, error)

Do executes the operation.

func (*ClusterStatsService) FlatSettings 

func (s *ClusterStatsService) FlatSettings(flatSettings bool) *ClusterStatsService

FlatSettings is documented as: Return settings in flat format (default: false).

func (*ClusterStatsService) Human 

func (s *ClusterStatsService) Human(human bool) *ClusterStatsService

Human is documented as: Whether to return time and byte values in human-readable format..

func (*ClusterStatsService) NodeId 

func (s *ClusterStatsService) NodeId(nodeId []string) *ClusterStatsService

NodeId is documented as: A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes.

func (*ClusterStatsService) Pretty 

func (s *ClusterStatsService) Pretty(pretty bool) *ClusterStatsService

Pretty indicates that the JSON response be indented and human readable.

func (*ClusterStatsService) Validate 

func (s *ClusterStatsService) Validate() error

Validate checks if the operation is valid.

type CommonQuery 

type CommonQuery struct {
	Query
	// contains filtered or unexported fields
}

The common terms query is a modern alternative to stopwords which improves the precision and recall of search results (by taking stopwords into account), without sacrificing performance. For more details, see: http://www.elasticsearch.org/guide/reference/query-dsl/common-terms-query/

func NewCommonQuery 

func NewCommonQuery(name string, query string) CommonQuery

Creates a new common query.

func (*CommonQuery) Analyzer 

func (q *CommonQuery) Analyzer(analyzer string) *CommonQuery

func (*CommonQuery) Boost 

func (q *CommonQuery) Boost(boost float64) *CommonQuery

func (*CommonQuery) CutoffFrequency 

func (q *CommonQuery) CutoffFrequency(f float64) *CommonQuery

func (*CommonQuery) DisableCoords 

func (q *CommonQuery) DisableCoords(disable bool) *CommonQuery

func (*CommonQuery) HighFreq 

func (q *CommonQuery) HighFreq(f float64) *CommonQuery

func (*CommonQuery) HighFreqMinMatch 

func (q *CommonQuery) HighFreqMinMatch(min interface{}) *CommonQuery

func (*CommonQuery) HighFreqOperator 

func (q *CommonQuery) HighFreqOperator(op string) *CommonQuery

func (*CommonQuery) LowFreq 

func (q *CommonQuery) LowFreq(f float64) *CommonQuery

func (*CommonQuery) LowFreqMinMatch 

func (q *CommonQuery) LowFreqMinMatch(min interface{}) *CommonQuery

func (*CommonQuery) LowFreqOperator 

func (q *CommonQuery) LowFreqOperator(op string) *CommonQuery

func (CommonQuery) Source 

func (q CommonQuery) Source() interface{}

Creates the query source for the common query.

type CompletionSuggester 

type CompletionSuggester struct {
	Suggester
	// contains filtered or unexported fields
}

CompletionSuggester is a fast suggester for e.g. type-ahead completion. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-suggesters-completion.html for more details.

func NewCompletionSuggester 

func NewCompletionSuggester(name string) CompletionSuggester

Creates a new completion suggester.

func (CompletionSuggester) Analyzer 

func (q CompletionSuggester) Analyzer(analyzer string) CompletionSuggester

func (CompletionSuggester) ContextQueries 

func (q CompletionSuggester) ContextQueries(queries ...SuggesterContextQuery) CompletionSuggester

func (CompletionSuggester) ContextQuery 

func (q CompletionSuggester) ContextQuery(query SuggesterContextQuery) CompletionSuggester

func (CompletionSuggester) Field 

func (q CompletionSuggester) Field(field string) CompletionSuggester

func (CompletionSuggester) Name 

func (q CompletionSuggester) Name() string

func (CompletionSuggester) ShardSize 

func (q CompletionSuggester) ShardSize(shardSize int) CompletionSuggester

func (CompletionSuggester) Size 

func (q CompletionSuggester) Size(size int) CompletionSuggester

func (CompletionSuggester) Source 

func (q CompletionSuggester) Source(includeName bool) interface{}

Creates the source for the completion suggester.

func (CompletionSuggester) Text 

func (q CompletionSuggester) Text(text string) CompletionSuggester

type ConstantScoreQuery 

type ConstantScoreQuery struct {
	// contains filtered or unexported fields
}

ConstantScoreQuery wraps a filter or another query and simply returns a constant score equal to the query boost for every document in the filter.

For more details, see https://www.elastic.co/guide/en/elasticsearch/reference/1.7/query-dsl-constant-score-query.html

func NewConstantScoreQuery 

func NewConstantScoreQuery() ConstantScoreQuery

NewConstantScoreQuery creates a new constant score query.

func (ConstantScoreQuery) Boost 

func (q ConstantScoreQuery) Boost(boost float64) ConstantScoreQuery

Boost sets the boost for this query. Documents matching this query will (in addition to the normal weightings) have their score multiplied by the boost provided.

func (ConstantScoreQuery) Filter 

func (q ConstantScoreQuery) Filter(filter Filter) ConstantScoreQuery

Filter to wrap in this constant score query.

func (ConstantScoreQuery) Query 

func (q ConstantScoreQuery) Query(query Query) ConstantScoreQuery

Query to wrap in this constant score query.

func (ConstantScoreQuery) Source 

func (q ConstantScoreQuery) Source() interface{}

Source returns JSON for the function score query.

type CountResponse 

type CountResponse struct {
	Count  int64      `json:"count"`
	Shards shardsInfo `json:"_shards,omitempty"`
}

CountResponse is the response of using the Count API.

type CountService 

type CountService struct {
	// contains filtered or unexported fields
}

CountService is a convenient service for determining the number of documents in an index. Use SearchService with a SearchType of count for counting with queries etc.

func NewCountService 

func NewCountService(client *Client) *CountService

NewCountService creates a new CountService.

func (*CountService) AllowNoIndices 

func (s *CountService) AllowNoIndices(allowNoIndices bool) *CountService

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 (*CountService) AnalyzeWildcard 

func (s *CountService) AnalyzeWildcard(analyzeWildcard bool) *CountService

AnalyzeWildcard specifies whether wildcard and prefix queries should be analyzed (default: false).

func (*CountService) Analyzer 

func (s *CountService) Analyzer(analyzer string) *CountService

Analyzer specifies the analyzer to use for the query string.

func (*CountService) BodyJson 

func (s *CountService) BodyJson(body interface{}) *CountService

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 (*CountService) BodyString 

func (s *CountService) BodyString(body string) *CountService

Body specifies a query to restrict the results specified with the Query DSL (optional).

func (*CountService) DefaultOperator 

func (s *CountService) DefaultOperator(defaultOperator string) *CountService

DefaultOperator specifies the default operator for query string query (AND or OR).

func (*CountService) Df 

func (s *CountService) Df(df string) *CountService

Df specifies the field to use as default where no field prefix is given in the query string.

func (*CountService) Do 

func (s *CountService) Do() (int64, error)

Do executes the operation.

func (*CountService) ExpandWildcards 

func (s *CountService) ExpandWildcards(expandWildcards string) *CountService

ExpandWildcards indicates whether to expand wildcard expression to concrete indices that are open, closed or both.

func (*CountService) IgnoreUnavailable 

func (s *CountService) IgnoreUnavailable(ignoreUnavailable bool) *CountService

IgnoreUnavailable indicates whether specified concrete indices should be ignored when unavailable (missing or closed).

func (*CountService) Index 

func (s *CountService) Index(index string) *CountService

Index sets the name of the index to use to restrict the results.

func (*CountService) Indices 

func (s *CountService) Indices(indices ...string) *CountService

Indices sets the names of the indices to restrict the results.

func (*CountService) Lenient 

func (s *CountService) Lenient(lenient bool) *CountService

Lenient specifies whether format-based query failures (such as providing text to a numeric field) should be ignored.

func (*CountService) LowercaseExpandedTerms 

func (s *CountService) LowercaseExpandedTerms(lowercaseExpandedTerms bool) *CountService

LowercaseExpandedTerms specifies whether query terms should be lowercased.

func (*CountService) MinScore 

func (s *CountService) MinScore(minScore interface{}) *CountService

MinScore indicates to include only documents with a specific `_score` value in the result.

func (*CountService) Preference 

func (s *CountService) Preference(preference string) *CountService

Preference specifies the node or shard the operation should be performed on (default: random).

func (*CountService) Pretty 

func (s *CountService) Pretty(pretty bool) *CountService

Pretty indicates that the JSON response be indented and human readable.

func (*CountService) Q 

func (s *CountService) Q(q string) *CountService

Q in the Lucene query string syntax. You can also use Query to pass a Query struct.

func (*CountService) Query 

func (s *CountService) Query(query Query) *CountService

Query specifies the query to pass. You can also pass a query string with Q.

func (*CountService) Routing 

func (s *CountService) Routing(routing string) *CountService

Routing specifies the routing value.

func (*CountService) Type 

func (s *CountService) Type(typ string) *CountService

Type sets the type to use to restrict the results.

func (*CountService) Types 

func (s *CountService) Types(types ...string) *CountService

Types sets the types to use to restrict the results.

func (*CountService) Validate 

func (s *CountService) Validate() error

Validate checks if the operation is valid.

type CreateIndexResult 

type CreateIndexResult struct {
	Acknowledged bool `json:"acknowledged"`
}

CreateIndexResult is the outcome of creating a new index.

type CreateIndexService 

type CreateIndexService struct {
	// contains filtered or unexported fields
}

CreateIndexService creates a new index.

Example 
package main

import (
	elastic "gopkg.in/olivere/elastic.v2"
)

func main() {
	// Get a client to the local Elasticsearch instance.
	client, err := elastic.NewClient()
	if err != nil {
		// Handle error
		panic(err)
	}
	// Create a new index.
	createIndex, err := client.CreateIndex("twitter").Do()
	if err != nil {
		// Handle error
		panic(err)
	}
	if !createIndex.Acknowledged {
		// Not acknowledged
	}
}

Output:

func NewCreateIndexService 

func NewCreateIndexService(client *Client) *CreateIndexService

NewCreateIndexService returns a new CreateIndexService.

func (*CreateIndexService) Body 

func (b *CreateIndexService) Body(body string) *CreateIndexService

Body specifies the configuration of the index as a string. It is an alias for BodyString.

func (*CreateIndexService) BodyJson 

func (b *CreateIndexService) BodyJson(body interface{}) *CreateIndexService

BodyJson specifies the configuration of the index. The interface{} will be serializes as a JSON document, so use a map[string]interface{}.

func (*CreateIndexService) BodyString 

func (b *CreateIndexService) BodyString(body string) *CreateIndexService

BodyString specifies the configuration of the index as a string.

func (*CreateIndexService) Do 

func (b *CreateIndexService) Do() (*CreateIndexResult, error)

Do executes the operation.

func (*CreateIndexService) Index 

func (b *CreateIndexService) Index(index string) *CreateIndexService

Index is the name of the index to create.

func (*CreateIndexService) MasterTimeout 

func (s *CreateIndexService) MasterTimeout(masterTimeout string) *CreateIndexService

MasterTimeout specifies the timeout for connection to master.

func (*CreateIndexService) Pretty 

func (b *CreateIndexService) Pretty(pretty bool) *CreateIndexService

Pretty indicates that the JSON response be indented and human readable.

func (*CreateIndexService) Timeout 

func (s *CreateIndexService) Timeout(timeout string) *CreateIndexService

Timeout the explicit operation timeout, e.g. "5s".

type CustomFiltersScoreQuery 

type CustomFiltersScoreQuery struct {
	// contains filtered or unexported fields
}

A custom_filters_score query allows to execute a query, and if the hit matches a provided filter (ordered), use either a boost or a script associated with it to compute the score.

For more details, see: http://www.elasticsearch.org/guide/reference/query-dsl/custom-filters-score-query/

func NewCustomFiltersScoreQuery 

func NewCustomFiltersScoreQuery() CustomFiltersScoreQuery

Creates a new custom_filters_score query.

func (CustomFiltersScoreQuery) Filter 

func (q CustomFiltersScoreQuery) Filter(filter Filter) CustomFiltersScoreQuery

func (CustomFiltersScoreQuery) MaxBoost 

func (q CustomFiltersScoreQuery) MaxBoost(maxBoost float32) CustomFiltersScoreQuery

func (CustomFiltersScoreQuery) Query 

func (q CustomFiltersScoreQuery) Query(query Query) CustomFiltersScoreQuery

func (CustomFiltersScoreQuery) ScoreMode 

func (q CustomFiltersScoreQuery) ScoreMode(scoreMode string) CustomFiltersScoreQuery

func (CustomFiltersScoreQuery) Script 

func (q CustomFiltersScoreQuery) Script(script string) CustomFiltersScoreQuery

func (CustomFiltersScoreQuery) Source 

func (q CustomFiltersScoreQuery) Source() interface{}

Creates the query source for the custom_filters_score query.

type CustomScoreQuery 

type CustomScoreQuery struct {
	// contains filtered or unexported fields
}

custom_score query allows to wrap another query and customize the scoring of it optionally with a computation derived from other field values in the doc (numeric ones) using script expression.

For more details, see: http://www.elasticsearch.org/guide/reference/query-dsl/custom-score-query/

func NewCustomScoreQuery 

func NewCustomScoreQuery() CustomScoreQuery

Creates a new custom_score query.

func (CustomScoreQuery) Boost 

func (q CustomScoreQuery) Boost(boost float32) CustomScoreQuery

func (CustomScoreQuery) Filter 

func (q CustomScoreQuery) Filter(filter Filter) CustomScoreQuery

func (CustomScoreQuery) Lang 

func (q CustomScoreQuery) Lang(lang string) CustomScoreQuery

func (CustomScoreQuery) Param 

func (q CustomScoreQuery) Param(name string, value interface{}) CustomScoreQuery

func (CustomScoreQuery) Params 

func (q CustomScoreQuery) Params(params map[string]interface{}) CustomScoreQuery

func (CustomScoreQuery) Query 

func (q CustomScoreQuery) Query(query Query) CustomScoreQuery

func (CustomScoreQuery) Script 

func (q CustomScoreQuery) Script(script string) CustomScoreQuery

func (CustomScoreQuery) Source 

func (q CustomScoreQuery) Source() interface{}

Creates the query source for the custom_fscore query.

type DateHistogramAggregation 

type DateHistogramAggregation struct {
	// contains filtered or unexported fields
}

DateHistogramAggregation is a multi-bucket aggregation similar to the histogram except it can only be applied on date values. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-datehistogram-aggregation.html

func NewDateHistogramAggregation 

func NewDateHistogramAggregation() DateHistogramAggregation

func (DateHistogramAggregation) ExtendedBoundsMax 

func (a DateHistogramAggregation) ExtendedBoundsMax(max interface{}) DateHistogramAggregation

ExtendedBoundsMax accepts int, int64, string, or time.Time values.

func (DateHistogramAggregation) ExtendedBoundsMin 

func (a DateHistogramAggregation) ExtendedBoundsMin(min interface{}) DateHistogramAggregation

ExtendedBoundsMin accepts int, int64, string, or time.Time values.

func (DateHistogramAggregation) Factor 

func (a DateHistogramAggregation) Factor(factor float32) DateHistogramAggregation

func (DateHistogramAggregation) Field 

func (a DateHistogramAggregation) Field(field string) DateHistogramAggregation

func (DateHistogramAggregation) Format 

func (a DateHistogramAggregation) Format(format string) DateHistogramAggregation

func (DateHistogramAggregation) Interval 

func (a DateHistogramAggregation) Interval(interval string) DateHistogramAggregation

Allowed values are: "year", "quarter", "month", "week", "day", "hour", "minute". It also supports time settings like "1.5h" (up to "w" for weeks).

func (DateHistogramAggregation) Lang 

func (a DateHistogramAggregation) Lang(lang string) DateHistogramAggregation

func (DateHistogramAggregation) MinDocCount 

func (a DateHistogramAggregation) MinDocCount(minDocCount int64) DateHistogramAggregation

func (DateHistogramAggregation) Order 

func (a DateHistogramAggregation) Order(order string, asc bool) DateHistogramAggregation

Order specifies the sort order. Valid values for order are: "_key", "_count", a sub-aggregation name, or a sub-aggregation name with a metric.

func (DateHistogramAggregation) OrderByAggregation 

func (a DateHistogramAggregation) OrderByAggregation(aggName string, asc bool) DateHistogramAggregation

OrderByAggregation creates a bucket ordering strategy which sorts buckets based on a single-valued calc get.

func (DateHistogramAggregation) OrderByAggregationAndMetric 

func (a DateHistogramAggregation) OrderByAggregationAndMetric(aggName, metric string, asc bool) DateHistogramAggregation

OrderByAggregationAndMetric creates a bucket ordering strategy which sorts buckets based on a multi-valued calc get.

func (DateHistogramAggregation) OrderByCount 

func (a DateHistogramAggregation) OrderByCount(asc bool) DateHistogramAggregation

func (DateHistogramAggregation) OrderByCountAsc 

func (a DateHistogramAggregation) OrderByCountAsc() DateHistogramAggregation

func (DateHistogramAggregation) OrderByCountDesc 

func (a DateHistogramAggregation) OrderByCountDesc() DateHistogramAggregation

func (DateHistogramAggregation) OrderByKey 

func (a DateHistogramAggregation) OrderByKey(asc bool) DateHistogramAggregation

func (DateHistogramAggregation) OrderByKeyAsc 

func (a DateHistogramAggregation) OrderByKeyAsc() DateHistogramAggregation

func (DateHistogramAggregation) OrderByKeyDesc 

func (a DateHistogramAggregation) OrderByKeyDesc() DateHistogramAggregation

func (DateHistogramAggregation) Param 

func (a DateHistogramAggregation) Param(name string, value interface{}) DateHistogramAggregation

func (DateHistogramAggregation) PostOffset 

func (a DateHistogramAggregation) PostOffset(postOffset int64) DateHistogramAggregation

func (DateHistogramAggregation) PostZone 

func (a DateHistogramAggregation) PostZone(postZone string) DateHistogramAggregation

func (DateHistogramAggregation) PreOffset 

func (a DateHistogramAggregation) PreOffset(preOffset int64) DateHistogramAggregation

func (DateHistogramAggregation) PreZone 

func (a DateHistogramAggregation) PreZone(preZone string) DateHistogramAggregation

func (DateHistogramAggregation) PreZoneAdjustLargeInterval 

func (a DateHistogramAggregation) PreZoneAdjustLargeInterval(preZoneAdjustLargeInterval bool) DateHistogramAggregation

func (DateHistogramAggregation) Script 

func (a DateHistogramAggregation) Script(script string) DateHistogramAggregation

func (DateHistogramAggregation) ScriptFile 

func (a DateHistogramAggregation) ScriptFile(scriptFile string) DateHistogramAggregation

func (DateHistogramAggregation) Source 

func (a DateHistogramAggregation) Source() interface{}

func (DateHistogramAggregation) SubAggregation 

func (a DateHistogramAggregation) SubAggregation(name string, subAggregation Aggregation) DateHistogramAggregation

type DateHistogramFacet 

type DateHistogramFacet struct {
	// contains filtered or unexported fields
}

A specific histogram facet that can work with date field types enhancing it over the regular histogram facet. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-facets-date-histogram-facet.html

func NewDateHistogramFacet 

func NewDateHistogramFacet() DateHistogramFacet

func (DateHistogramFacet) Comparator 

func (f DateHistogramFacet) Comparator(comparator string) DateHistogramFacet

func (DateHistogramFacet) FacetFilter 

func (f DateHistogramFacet) FacetFilter(filter Facet) DateHistogramFacet

func (DateHistogramFacet) Factor 

func (f DateHistogramFacet) Factor(factor float32) DateHistogramFacet

func (DateHistogramFacet) Field 

func (f DateHistogramFacet) Field(field string) DateHistogramFacet

func (DateHistogramFacet) Global 

func (f DateHistogramFacet) Global(global bool) DateHistogramFacet

func (DateHistogramFacet) Interval 

func (f DateHistogramFacet) Interval(interval string) DateHistogramFacet

Allowed values are: "year", "quarter", "month", "week", "day", "hour", "minute". It also supports time settings like "1.5h" (up to "w" for weeks).

func (DateHistogramFacet) KeyField 

func (f DateHistogramFacet) KeyField(keyField string) DateHistogramFacet

func (DateHistogramFacet) Lang 

func (f DateHistogramFacet) Lang(lang string) DateHistogramFacet

func (DateHistogramFacet) Mode 

func (f DateHistogramFacet) Mode(mode string) DateHistogramFacet

func (DateHistogramFacet) Nested 

func (f DateHistogramFacet) Nested(nested string) DateHistogramFacet

func (DateHistogramFacet) Param 

func (f DateHistogramFacet) Param(name string, value interface{}) DateHistogramFacet

func (DateHistogramFacet) PostOffset 

func (f DateHistogramFacet) PostOffset(postOffset string) DateHistogramFacet

func (DateHistogramFacet) PostZone 

func (f DateHistogramFacet) PostZone(postZone string) DateHistogramFacet

func (DateHistogramFacet) PreOffset 

func (f DateHistogramFacet) PreOffset(preOffset string) DateHistogramFacet

func (DateHistogramFacet) PreZone 

func (f DateHistogramFacet) PreZone(preZone string) DateHistogramFacet

func (DateHistogramFacet) PreZoneAdjustLargeInterval 

func (f DateHistogramFacet) PreZoneAdjustLargeInterval(preZoneAdjustLargeInterval bool) DateHistogramFacet

func (DateHistogramFacet) Source 

func (f DateHistogramFacet) Source() interface{}

func (DateHistogramFacet) ValueField 

func (f DateHistogramFacet) ValueField(valueField string) DateHistogramFacet

func (DateHistogramFacet) ValueScript 

func (f DateHistogramFacet) ValueScript(valueScript string) DateHistogramFacet

type DateRangeAggregation 

type DateRangeAggregation struct {
	// contains filtered or unexported fields
}

DateRangeAggregation is a range aggregation that is dedicated for date values. The main difference between this aggregation and the normal range aggregation is that the from and to values can be expressed in Date Math expressions, and it is also possible to specify a date format by which the from and to response fields will be returned. Note that this aggregration includes the from value and excludes the to value for each range. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-daterange-aggregation.html

func NewDateRangeAggregation 

func NewDateRangeAggregation() DateRangeAggregation

func (DateRangeAggregation) AddRange 

func (a DateRangeAggregation) AddRange(from, to interface{}) DateRangeAggregation

func (DateRangeAggregation) AddRangeWithKey 

func (a DateRangeAggregation) AddRangeWithKey(key string, from, to interface{}) DateRangeAggregation

func (DateRangeAggregation) AddUnboundedFrom 

func (a DateRangeAggregation) AddUnboundedFrom(to interface{}) DateRangeAggregation

func (DateRangeAggregation) AddUnboundedFromWithKey 

func (a DateRangeAggregation) AddUnboundedFromWithKey(key string, to interface{}) DateRangeAggregation

func (DateRangeAggregation) AddUnboundedTo 

func (a DateRangeAggregation) AddUnboundedTo(from interface{}) DateRangeAggregation

func (DateRangeAggregation) AddUnboundedToWithKey 

func (a DateRangeAggregation) AddUnboundedToWithKey(key string, from interface{}) DateRangeAggregation

func (DateRangeAggregation) Between 

func (a DateRangeAggregation) Between(from, to interface{}) DateRangeAggregation

func (DateRangeAggregation) BetweenWithKey 

func (a DateRangeAggregation) BetweenWithKey(key string, from, to interface{}) DateRangeAggregation

func (DateRangeAggregation) Field 

func (a DateRangeAggregation) Field(field string) DateRangeAggregation

func (DateRangeAggregation) Format 

func (a DateRangeAggregation) Format(format string) DateRangeAggregation

func (DateRangeAggregation) Gt 

func (a DateRangeAggregation) Gt(from interface{}) DateRangeAggregation

func (DateRangeAggregation) GtWithKey 

func (a DateRangeAggregation) GtWithKey(key string, from interface{}) DateRangeAggregation

func (DateRangeAggregation) Keyed 

func (a DateRangeAggregation) Keyed(keyed bool) DateRangeAggregation

func (DateRangeAggregation) Lang 

func (a DateRangeAggregation) Lang(lang string) DateRangeAggregation

func (DateRangeAggregation) Lt 

func (a DateRangeAggregation) Lt(to interface{}) DateRangeAggregation

func (DateRangeAggregation) LtWithKey 

func (a DateRangeAggregation) LtWithKey(key string, to interface{}) DateRangeAggregation

func (DateRangeAggregation) Param 

func (a DateRangeAggregation) Param(name string, value interface{}) DateRangeAggregation

func (DateRangeAggregation) Script 

func (a DateRangeAggregation) Script(script string) DateRangeAggregation

func (DateRangeAggregation) ScriptFile 

func (a DateRangeAggregation) ScriptFile(scriptFile string) DateRangeAggregation

func (DateRangeAggregation) Source 

func (a DateRangeAggregation) Source() interface{}

func (DateRangeAggregation) SubAggregation 

func (a DateRangeAggregation) SubAggregation(name string, subAggregation Aggregation) DateRangeAggregation

func (DateRangeAggregation) Unmapped 

func (a DateRangeAggregation) Unmapped(unmapped bool) DateRangeAggregation

type DateRangeAggregationEntry 

type DateRangeAggregationEntry struct {
	Key  string
	From interface{}
	To   interface{}
}

type Decoder 

type Decoder interface {
	Decode(data []byte, v interface{}) error
}

Decoder is used to decode responses from Elasticsearch. Users of elastic can implement their own marshaler for advanced purposes and set them per Client (see SetDecoder). If none is specified, DefaultDecoder is used.

type DefaultDecoder 

type DefaultDecoder struct{}

DefaultDecoder uses json.Unmarshal from the Go standard library to decode JSON data.

func (*DefaultDecoder) Decode 

func (u *DefaultDecoder) Decode(data []byte, v interface{}) error

Decode decodes with json.Unmarshal from the Go standard library.

type DeleteByQueryResult 

type DeleteByQueryResult struct {
	Indices map[string]IndexDeleteByQueryResult `json:"_indices"`
}

DeleteByQueryResult is the outcome of executing Do with DeleteByQueryService.

type DeleteByQueryService 

type DeleteByQueryService struct {
	// contains filtered or unexported fields
}

DeleteByQueryService deletes documents that match a query. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/docs-delete-by-query.html.

func NewDeleteByQueryService 

func NewDeleteByQueryService(client *Client) *DeleteByQueryService

NewDeleteByQueryService creates a new DeleteByQueryService. You typically use the client's DeleteByQuery to get a reference to the service.

func (*DeleteByQueryService) AllowNoIndices 

func (s *DeleteByQueryService) AllowNoIndices(allow bool) *DeleteByQueryService

AllowNoIndices indicates whether to ignore if a wildcard indices expression resolves into no concrete indices (including the _all string or when no indices have been specified).

func (*DeleteByQueryService) Analyzer 

func (s *DeleteByQueryService) Analyzer(analyzer string) *DeleteByQueryService

Analyzer to use for the query string.

func (*DeleteByQueryService) Consistency 

func (s *DeleteByQueryService) Consistency(consistency string) *DeleteByQueryService

Consistency represents the specific write consistency setting for the operation. It can be one, quorum, or all.

func (*DeleteByQueryService) DF 

func (s *DeleteByQueryService) DF(defaultField string) *DeleteByQueryService

DF is the field to use as default where no field prefix is given in the query string.

func (*DeleteByQueryService) DefaultField 

func (s *DeleteByQueryService) DefaultField(defaultField string) *DeleteByQueryService

DefaultField is the field to use as default where no field prefix is given in the query string. It is an alias to the DF func.

func (*DeleteByQueryService) DefaultOperator 

func (s *DeleteByQueryService) DefaultOperator(defaultOperator string) *DeleteByQueryService

DefaultOperator for query string query (AND or OR).

func (*DeleteByQueryService) Do 

func (s *DeleteByQueryService) Do() (*DeleteByQueryResult, error)

Do executes the delete-by-query operation.

func (*DeleteByQueryService) ExpandWildcards 

func (s *DeleteByQueryService) ExpandWildcards(expand string) *DeleteByQueryService

ExpandWildcards indicates whether to expand wildcard expression to concrete indices that are open, closed or both. It can be "open" or "closed".

func (*DeleteByQueryService) IgnoreUnavailable 

func (s *DeleteByQueryService) IgnoreUnavailable(ignore bool) *DeleteByQueryService

IgnoreUnavailable indicates whether specified concrete indices should be ignored when unavailable (missing or closed).

func (*DeleteByQueryService) Index 

func (s *DeleteByQueryService) Index(index string) *DeleteByQueryService

Index limits the delete-by-query to a single index. You can use _all to perform the operation on all indices.

func (*DeleteByQueryService) Indices 

func (s *DeleteByQueryService) Indices(indices ...string) *DeleteByQueryService

Indices sets the indices on which to perform the delete operation.

func (*DeleteByQueryService) Pretty 

func (s *DeleteByQueryService) Pretty(pretty bool) *DeleteByQueryService

Pretty indents the JSON output from Elasticsearch.

func (*DeleteByQueryService) Q 

func (s *DeleteByQueryService) Q(query string) *DeleteByQueryService

Q specifies the query in Lucene query string syntax. You can also use Query to programmatically specify the query.

func (*DeleteByQueryService) Query 

func (s *DeleteByQueryService) Query(query Query) *DeleteByQueryService

Query sets the query programmatically.

func (*DeleteByQueryService) QueryString 

func (s *DeleteByQueryService) QueryString(query string) *DeleteByQueryService

QueryString is an alias to Q. Notice that you can also use Query to programmatically set the query.

func (*DeleteByQueryService) Replication 

func (s *DeleteByQueryService) Replication(replication string) *DeleteByQueryService

Replication sets a specific replication type (sync or async).

func (*DeleteByQueryService) Routing 

func (s *DeleteByQueryService) Routing(routing string) *DeleteByQueryService

Routing sets a specific routing value.

func (*DeleteByQueryService) Timeout 

func (s *DeleteByQueryService) Timeout(timeout string) *DeleteByQueryService

Timeout sets an explicit operation timeout, e.g. "1s" or "10000ms".

func (*DeleteByQueryService) Type 

func (s *DeleteByQueryService) Type(typ string) *DeleteByQueryService

Type limits the delete operation to the given type.

func (*DeleteByQueryService) Types 

func (s *DeleteByQueryService) Types(types ...string) *DeleteByQueryService

Types limits the delete operation to the given types.

type DeleteIndexResult 

type DeleteIndexResult struct {
	Acknowledged bool `json:"acknowledged"`
}

type DeleteIndexService 

type DeleteIndexService struct {
	// contains filtered or unexported fields
}
Example 
package main

import (
	elastic "gopkg.in/olivere/elastic.v2"
)

func main() {
	// Get a client to the local Elasticsearch instance.
	client, err := elastic.NewClient()
	if err != nil {
		// Handle error
		panic(err)
	}
	// Delete an index.
	deleteIndex, err := client.DeleteIndex("twitter").Do()
	if err != nil {
		// Handle error
		panic(err)
	}
	if !deleteIndex.Acknowledged {
		// Not acknowledged
	}
}

Output:

func NewDeleteIndexService 

func NewDeleteIndexService(client *Client) *DeleteIndexService

func (*DeleteIndexService) Do 

func (b *DeleteIndexService) Do() (*DeleteIndexResult, error)

func (*DeleteIndexService) Index 

func (b *DeleteIndexService) Index(index string) *DeleteIndexService

type DeleteMappingResponse 

type DeleteMappingResponse struct {
	Acknowledged bool `json:"acknowledged"`
}

DeleteMappingResponse is the response of DeleteMappingService.Do.

type DeleteMappingService 

type DeleteMappingService struct {
	// contains filtered or unexported fields
}

DeleteMappingService allows to delete a mapping along with its data. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-delete-mapping.html.

func NewDeleteMappingService 

func NewDeleteMappingService(client *Client) *DeleteMappingService

NewDeleteMappingService creates a new DeleteMappingService.

func (*DeleteMappingService) Do 

func (s *DeleteMappingService) Do() (*DeleteMappingResponse, error)

Do executes the operation.

func (*DeleteMappingService) Index 

func (s *DeleteMappingService) Index(index ...string) *DeleteMappingService

Index is a list of index names (supports wildcards). Use `_all` for all indices.

func (*DeleteMappingService) MasterTimeout 

func (s *DeleteMappingService) MasterTimeout(masterTimeout string) *DeleteMappingService

MasterTimeout specifies the timeout for connecting to master.

func (*DeleteMappingService) Pretty 

func (s *DeleteMappingService) Pretty(pretty bool) *DeleteMappingService

Pretty indicates that the JSON response be indented and human readable.

func (*DeleteMappingService) Type 

func (s *DeleteMappingService) Type(typ ...string) *DeleteMappingService

Type is a list of document types to delete (supports wildcards). Use `_all` to delete all document types in the specified indices..

func (*DeleteMappingService) Validate 

func (s *DeleteMappingService) Validate() error

Validate checks if the operation is valid.

type DeleteResult 

type DeleteResult struct {
	Found   bool   `json:"found"`
	Index   string `json:"_index"`
	Type    string `json:"_type"`
	Id      string `json:"_id"`
	Version int64  `json:"_version"`
}

type DeleteService 

type DeleteService struct {
	// contains filtered or unexported fields
}

func NewDeleteService 

func NewDeleteService(client *Client) *DeleteService

func (*DeleteService) Do 

func (s *DeleteService) Do() (*DeleteResult, error)

Do deletes the document. It fails if any of index, type, and identifier are missing.

func (*DeleteService) Id 

func (s *DeleteService) Id(id string) *DeleteService

func (*DeleteService) Index 

func (s *DeleteService) Index(index string) *DeleteService

func (*DeleteService) Parent 

func (s *DeleteService) Parent(parent string) *DeleteService

func (*DeleteService) Pretty 

func (s *DeleteService) Pretty(pretty bool) *DeleteService

func (*DeleteService) Refresh 

func (s *DeleteService) Refresh(refresh bool) *DeleteService

func (*DeleteService) Type 

func (s *DeleteService) Type(_type string) *DeleteService

func (*DeleteService) Version 

func (s *DeleteService) Version(version int) *DeleteService

type DeleteTemplateResponse 

type DeleteTemplateResponse struct {
	Found   bool   `json:"found"`
	Index   string `json:"_index"`
	Type    string `json:"_type"`
	Id      string `json:"_id"`
	Version int    `json:"_version"`
}

DeleteTemplateResponse is the response of DeleteTemplateService.Do.

type DeleteTemplateService 

type DeleteTemplateService struct {
	// contains filtered or unexported fields
}

DeleteTemplateService deletes a search template. More information can be found at http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html.

Example 
package main

import (
	"fmt"

	elastic "gopkg.in/olivere/elastic.v2"
)

func main() {
	client, err := elastic.NewClient()
	if err != nil {
		panic(err)
	}

	// Delete template
	resp, err := client.DeleteTemplate().Id("my-search-template").Do()
	if err != nil {
		panic(err)
	}
	if resp != nil && resp.Found {
		fmt.Println("template deleted")
	}
}

Output:

func NewDeleteTemplateService 

func NewDeleteTemplateService(client *Client) *DeleteTemplateService

NewDeleteTemplateService creates a new DeleteTemplateService.

func (*DeleteTemplateService) Do 

func (s *DeleteTemplateService) Do() (*DeleteTemplateResponse, error)

Do executes the operation.

func (*DeleteTemplateService) Id 

func (s *DeleteTemplateService) Id(id string) *DeleteTemplateService

Id is the template ID.

func (*DeleteTemplateService) Validate 

func (s *DeleteTemplateService) Validate() error

Validate checks if the operation is valid.

func (*DeleteTemplateService) Version 

func (s *DeleteTemplateService) Version(version int) *DeleteTemplateService

Version an explicit version number for concurrency control.

func (*DeleteTemplateService) VersionType 

func (s *DeleteTemplateService) VersionType(versionType string) *DeleteTemplateService

VersionType specifies a version type.

type DeleteWarmerResponse 

type DeleteWarmerResponse struct {
	Acknowledged bool `json:"acknowledged"`
}

DeleteWarmerResponse is the response of IndicesDeleteWarmerService.Do.

type DirectCandidateGenerator 

type DirectCandidateGenerator struct {
	// contains filtered or unexported fields
}

DirectCandidateGenerator implements a direct candidate generator. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-suggesters-phrase.html#_smoothing_models for details about smoothing models.

func NewDirectCandidateGenerator 

func NewDirectCandidateGenerator(field string) *DirectCandidateGenerator

func (*DirectCandidateGenerator) Accuracy 

func (g *DirectCandidateGenerator) Accuracy(accuracy float64) *DirectCandidateGenerator

func (*DirectCandidateGenerator) Field 

func (g *DirectCandidateGenerator) Field(field string) *DirectCandidateGenerator

func (*DirectCandidateGenerator) MaxEdits 

func (g *DirectCandidateGenerator) MaxEdits(maxEdits int) *DirectCandidateGenerator

func (*DirectCandidateGenerator) MaxInspections 

func (g *DirectCandidateGenerator) MaxInspections(maxInspections int) *DirectCandidateGenerator

func (*DirectCandidateGenerator) MaxTermFreq 

func (g *DirectCandidateGenerator) MaxTermFreq(maxTermFreq float64) *DirectCandidateGenerator

func (*DirectCandidateGenerator) MinDocFreq 

func (g *DirectCandidateGenerator) MinDocFreq(minDocFreq float64) *DirectCandidateGenerator

func (*DirectCandidateGenerator) MinWordLength 

func (g *DirectCandidateGenerator) MinWordLength(minWordLength int) *DirectCandidateGenerator

func (*DirectCandidateGenerator) PostFilter 

func (g *DirectCandidateGenerator) PostFilter(postFilter string) *DirectCandidateGenerator

func (*DirectCandidateGenerator) PreFilter 

func (g *DirectCandidateGenerator) PreFilter(preFilter string) *DirectCandidateGenerator

func (*DirectCandidateGenerator) PrefixLength 

func (g *DirectCandidateGenerator) PrefixLength(prefixLength int) *DirectCandidateGenerator

func (*DirectCandidateGenerator) Size 

func (g *DirectCandidateGenerator) Size(size int) *DirectCandidateGenerator

func (*DirectCandidateGenerator) Sort 

func (g *DirectCandidateGenerator) Sort(sort string) *DirectCandidateGenerator

func (*DirectCandidateGenerator) Source 

func (g *DirectCandidateGenerator) Source() interface{}

func (*DirectCandidateGenerator) StringDistance 

func (g *DirectCandidateGenerator) StringDistance(stringDistance string) *DirectCandidateGenerator

func (*DirectCandidateGenerator) SuggestMode 

func (g *DirectCandidateGenerator) SuggestMode(suggestMode string) *DirectCandidateGenerator

func (*DirectCandidateGenerator) Type 

func (g *DirectCandidateGenerator) Type() string

type DisMaxQuery 

type DisMaxQuery struct {
	// contains filtered or unexported fields
}

A query that generates the union of documents produced by its subqueries, and that scores each document with the maximum score for that document as produced by any subquery, plus a tie breaking increment for any additional matching subqueries.

For more details, see: http://www.elasticsearch.org/guide/reference/query-dsl/dis-max-query/

func NewDisMaxQuery 

func NewDisMaxQuery() DisMaxQuery

Creates a new dis_max query.

func (DisMaxQuery) Boost 

func (q DisMaxQuery) Boost(boost float32) DisMaxQuery

func (DisMaxQuery) Query 

func (q DisMaxQuery) Query(query Query) DisMaxQuery

func (DisMaxQuery) Source 

func (q DisMaxQuery) Source() interface{}

Creates the query source for the dis_max query.

func (DisMaxQuery) TieBreaker 

func (q DisMaxQuery) TieBreaker(tieBreaker float32) DisMaxQuery

type Error 

type Error struct {
	Status  int    `json:"status"`
	Message string `json:"error"`
}

func (*Error) Error 

func (e *Error) Error() string

type ExistsFilter 

type ExistsFilter struct {
	Filter
	// contains filtered or unexported fields
}

Filters documents where a specific field has a value in them. For details, see: http://www.elasticsearch.org/guide/reference/query-dsl/exists-filter.html

func NewExistsFilter 

func NewExistsFilter(name string) ExistsFilter

func (ExistsFilter) FilterName 

func (f ExistsFilter) FilterName(filterName string) ExistsFilter

func (ExistsFilter) Source 

func (f ExistsFilter) Source() interface{}

type ExistsService 

type ExistsService struct {
	// contains filtered or unexported fields
}

ExistsService checks if a document exists.

See http://www.elastic.co/guide/en/elasticsearch/reference/current/docs-get.html for details.

func NewExistsService 

func NewExistsService(client *Client) *ExistsService

NewExistsService creates a new ExistsService.

func (*ExistsService) Do 

func (s *ExistsService) Do() (bool, error)

Do executes the operation.

func (*ExistsService) Id 

func (s *ExistsService) Id(id string) *ExistsService

Id is the document ID.

func (*ExistsService) Index 

func (s *ExistsService) Index(index string) *ExistsService

Index is the name of the index.

func (*ExistsService) Parent 

func (s *ExistsService) Parent(parent string) *ExistsService

Parent is the ID of the parent document.

func (*ExistsService) Preference 

func (s *ExistsService) Preference(preference string) *ExistsService

Preference specifies the node or shard the operation should be performed on (default: random).

func (*ExistsService) Pretty 

func (s *ExistsService) Pretty(pretty bool) *ExistsService

Pretty indicates that the JSON response be indented and human readable.

func (*ExistsService) Realtime 

func (s *ExistsService) Realtime(realtime bool) *ExistsService

Realtime specifies whether to perform the operation in realtime or search mode.

func (*ExistsService) Refresh 

func (s *ExistsService) Refresh(refresh bool) *ExistsService

Refresh the shard containing the document before performing the operation.

func (*ExistsService) Routing 

func (s *ExistsService) Routing(routing string) *ExistsService

Routing is the specific routing value.

func (*ExistsService) Type 

func (s *ExistsService) Type(typ string) *ExistsService

Type is the type of the document (use `_all` to fetch the first document matching the ID across all types).

func (*ExistsService) Validate 

func (s *ExistsService) Validate() error

Validate checks if the operation is valid.

type ExplainResponse 

type ExplainResponse struct {
	Index       string                 `json:"_index"`
	Type        string                 `json:"_type"`
	Id          string                 `json:"_id"`
	Matched     bool                   `json:"matched"`
	Explanation map[string]interface{} `json:"explanation"`
}

ExplainResponse is the response of ExplainService.Do.

type ExplainService 

type ExplainService struct {
	// contains filtered or unexported fields
}

ExplainService computes a score explanation for a query and a specific document. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-explain.html.

func NewExplainService 

func NewExplainService(client *Client) *ExplainService

NewExplainService creates a new ExplainService.

func (*ExplainService) AnalyzeWildcard 

func (s *ExplainService) AnalyzeWildcard(analyzeWildcard bool) *ExplainService

AnalyzeWildcard specifies whether wildcards and prefix queries in the query string query should be analyzed (default: false).

func (*ExplainService) Analyzer 

func (s *ExplainService) Analyzer(analyzer string) *ExplainService

Analyzer is the analyzer for the query string query.

func (*ExplainService) BodyJson 

func (s *ExplainService) BodyJson(body interface{}) *ExplainService

BodyJson sets the query definition using the Query DSL.

func (*ExplainService) BodyString 

func (s *ExplainService) BodyString(body string) *ExplainService

BodyString sets the query definition using the Query DSL as a string.

func (*ExplainService) DefaultOperator 

func (s *ExplainService) DefaultOperator(defaultOperator string) *ExplainService

DefaultOperator is the default operator for query string query (AND or OR).

func (*ExplainService) Df 

func (s *ExplainService) Df(df string) *ExplainService

Df is the default field for query string query (default: _all).

func (*ExplainService) Do 

func (s *ExplainService) Do() (*ExplainResponse, error)

Do executes the operation.

func (*ExplainService) Fields 

func (s *ExplainService) Fields(fields ...string) *ExplainService

Fields is a list of fields to return in the response.

func (*ExplainService) Id 

func (s *ExplainService) Id(id string) *ExplainService

Id is the document ID.

func (*ExplainService) Index 

func (s *ExplainService) Index(index string) *ExplainService

Index is the name of the index.

func (*ExplainService) Lenient 

func (s *ExplainService) Lenient(lenient bool) *ExplainService

Lenient specifies whether format-based query failures (such as providing text to a numeric field) should be ignored.

func (*ExplainService) LowercaseExpandedTerms 

func (s *ExplainService) LowercaseExpandedTerms(lowercaseExpandedTerms bool) *ExplainService

LowercaseExpandedTerms specifies whether query terms should be lowercased.

func (*ExplainService) Parent 

func (s *ExplainService) Parent(parent string) *ExplainService

Parent is the ID of the parent document.

func (*ExplainService) Preference 

func (s *ExplainService) Preference(preference string) *ExplainService

Preference specifies the node or shard the operation should be performed on (default: random).

func (*ExplainService) Pretty 

func (s *ExplainService) Pretty(pretty bool) *ExplainService

Pretty indicates that the JSON response be indented and human readable.

func (*ExplainService) Q 

func (s *ExplainService) Q(q string) *ExplainService

Query in the Lucene query string syntax.

func (*ExplainService) Query 

func (s *ExplainService) Query(query Query) *ExplainService

Query sets a query definition using the Query DSL.

func (*ExplainService) Routing 

func (s *ExplainService) Routing(routing string) *ExplainService

Routing sets a specific routing value.

func (*ExplainService) Source 

func (s *ExplainService) Source(source string) *ExplainService

Source is the URL-encoded query definition (instead of using the request body).

func (*ExplainService) Type 

func (s *ExplainService) Type(typ string) *ExplainService

Type is the type of the document.

func (*ExplainService) Validate 

func (s *ExplainService) Validate() error

Validate checks if the operation is valid.

func (*ExplainService) XSource 

func (s *ExplainService) XSource(xSource ...string) *ExplainService

XSource is true or false to return the _source field or not, or a list of fields to return.

func (*ExplainService) XSourceExclude 

func (s *ExplainService) XSourceExclude(xSourceExclude ...string) *ExplainService

XSourceExclude is a list of fields to exclude from the returned _source field.

func (*ExplainService) XSourceInclude 

func (s *ExplainService) XSourceInclude(xSourceInclude ...string) *ExplainService

XSourceInclude is a list of fields to extract and return from the _source field.

type ExponentialDecayFunction 

type ExponentialDecayFunction struct {
	// contains filtered or unexported fields
}

ExponentialDecayFunction builds an exponential decay score function. See https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-function-score-query.html for details.

func NewExponentialDecayFunction 

func NewExponentialDecayFunction() ExponentialDecayFunction

NewExponentialDecayFunction creates a new ExponentialDecayFunction.

func (ExponentialDecayFunction) Decay 

func (fn ExponentialDecayFunction) Decay(decay float64) ExponentialDecayFunction

Decay defines how documents are scored at the distance given a Scale. If no decay is defined, documents at the distance Scale will be scored 0.5.

func (ExponentialDecayFunction) FieldName 

func (fn ExponentialDecayFunction) FieldName(fieldName string) ExponentialDecayFunction

FieldName specifies the name of the field to which this decay function is applied to.

func (ExponentialDecayFunction) GetWeight 

func (fn ExponentialDecayFunction) GetWeight() *float64

GetWeight returns the adjusted score. It is part of the ScoreFunction interface. Returns nil if weight is not specified.

func (ExponentialDecayFunction) MultiValueMode 

func (fn ExponentialDecayFunction) MultiValueMode(mode string) ExponentialDecayFunction

MultiValueMode specifies how the decay function should be calculated on a field that has multiple values. Valid modes are: min, max, avg, and sum.

func (ExponentialDecayFunction) Name 

func (fn ExponentialDecayFunction) Name() string

Name represents the JSON field name under which the output of Source needs to be serialized by FunctionScoreQuery (see FunctionScoreQuery.Source).

func (ExponentialDecayFunction) Offset 

func (fn ExponentialDecayFunction) Offset(offset interface{}) ExponentialDecayFunction

Offset, if defined, computes the decay function only for a distance greater than the defined offset.

func (ExponentialDecayFunction) Origin 

func (fn ExponentialDecayFunction) Origin(origin interface{}) ExponentialDecayFunction

Origin defines the "central point" by which the decay function calculates "distance".

func (ExponentialDecayFunction) Scale 

func (fn ExponentialDecayFunction) Scale(scale interface{}) ExponentialDecayFunction

Scale defines the scale to be used with Decay.

func (ExponentialDecayFunction) Source 

func (fn ExponentialDecayFunction) Source() interface{}

Source returns the serializable JSON data of this score function.

func (ExponentialDecayFunction) Weight 

func (fn ExponentialDecayFunction) Weight(weight float64) ExponentialDecayFunction

Weight adjusts the score of the score function. See https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-function-score-query.html#_using_function_score for details.

type ExtendedStatsAggregation 

type ExtendedStatsAggregation struct {
	// contains filtered or unexported fields
}

ExtendedExtendedStatsAggregation is a multi-value metrics aggregation that computes stats over numeric values extracted from the aggregated documents. These values can be extracted either from specific numeric fields in the documents, or be generated by a provided script. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-metrics-extendedstats-aggregation.html

func NewExtendedStatsAggregation 

func NewExtendedStatsAggregation() ExtendedStatsAggregation

func (ExtendedStatsAggregation) Field 

func (a ExtendedStatsAggregation) Field(field string) ExtendedStatsAggregation

func (ExtendedStatsAggregation) Format 

func (a ExtendedStatsAggregation) Format(format string) ExtendedStatsAggregation

func (ExtendedStatsAggregation) Lang 

func (a ExtendedStatsAggregation) Lang(lang string) ExtendedStatsAggregation

func (ExtendedStatsAggregation) Param 

func (a ExtendedStatsAggregation) Param(name string, value interface{}) ExtendedStatsAggregation

func (ExtendedStatsAggregation) Script 

func (a ExtendedStatsAggregation) Script(script string) ExtendedStatsAggregation

func (ExtendedStatsAggregation) ScriptFile 

func (a ExtendedStatsAggregation) ScriptFile(scriptFile string) ExtendedStatsAggregation

func (ExtendedStatsAggregation) Source 

func (a ExtendedStatsAggregation) Source() interface{}

func (ExtendedStatsAggregation) SubAggregation 

func (a ExtendedStatsAggregation) SubAggregation(name string, subAggregation Aggregation) ExtendedStatsAggregation

type Facet 

type Facet interface {
	Source() interface{}
}

Represents a glimpse into the data. For more details about facets, visit: http://elasticsearch.org/guide/reference/api/search/facets/

type FactorFunction 

type FactorFunction struct {
	// contains filtered or unexported fields
}

FactorFunction is deprecated. See https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-function-score-query.html for details.

func NewFactorFunction 

func NewFactorFunction() FactorFunction

NewFactorFunction initializes and returns a new FactorFunction.

func (FactorFunction) BoostFactor 

func (fn FactorFunction) BoostFactor(boost float32) FactorFunction

BoostFactor specifies a boost for this score function.

func (FactorFunction) GetWeight 

func (fn FactorFunction) GetWeight() *float64

GetWeight always returns nil for (deprecated) FactorFunction.

func (FactorFunction) Name 

func (fn FactorFunction) Name() string

Name represents the JSON field name under which the output of Source needs to be serialized by FunctionScoreQuery (see FunctionScoreQuery.Source).

func (FactorFunction) Source 

func (fn FactorFunction) Source() interface{}

Source returns the serializable JSON data of this score function.

type FetchSourceContext 

type FetchSourceContext struct {
	// contains filtered or unexported fields
}

func NewFetchSourceContext 

func NewFetchSourceContext(fetchSource bool) *FetchSourceContext

func (*FetchSourceContext) Exclude 

func (fsc *FetchSourceContext) Exclude(excludes ...string) *FetchSourceContext

func (*FetchSourceContext) FetchSource 

func (fsc *FetchSourceContext) FetchSource() bool

func (*FetchSourceContext) Include 

func (fsc *FetchSourceContext) Include(includes ...string) *FetchSourceContext

func (*FetchSourceContext) Query 

func (fsc *FetchSourceContext) Query() url.Values

Query returns the parameters in a form suitable for a URL query string.

func (*FetchSourceContext) SetFetchSource 

func (fsc *FetchSourceContext) SetFetchSource(fetchSource bool)

func (*FetchSourceContext) Source 

func (fsc *FetchSourceContext) Source() interface{}

func (*FetchSourceContext) TransformSource 

func (fsc *FetchSourceContext) TransformSource(transformSource bool) *FetchSourceContext

type FieldSort 

type FieldSort struct {
	Sorter
	// contains filtered or unexported fields
}

FieldSort sorts by a given field.

func NewFieldSort 

func NewFieldSort(fieldName string) FieldSort

NewFieldSort creates a new FieldSort.

func (FieldSort) Asc 

func (s FieldSort) Asc() FieldSort

Asc sets ascending sort order.

func (FieldSort) Desc 

func (s FieldSort) Desc() FieldSort

Desc sets descending sort order.

func (FieldSort) FieldName 

func (s FieldSort) FieldName(fieldName string) FieldSort

FieldName specifies the name of the field to be used for sorting.

func (FieldSort) IgnoreUnmapped 

func (s FieldSort) IgnoreUnmapped(ignoreUnmapped bool) FieldSort

IgnoreUnmapped specifies what happens if the field does not exist in the index. Set it to true to ignore, or set it to false to not ignore (default).

func (FieldSort) Missing 

func (s FieldSort) Missing(missing interface{}) FieldSort

Missing sets the value to be used when a field is missing in a document. You can also use "_last" or "_first" to sort missing last or first respectively.

func (FieldSort) NestedFilter 

func (s FieldSort) NestedFilter(nestedFilter Filter) FieldSort

NestedFilter sets a filter that nested objects should match with in order to be taken into account for sorting.

func (FieldSort) NestedPath 

func (s FieldSort) NestedPath(nestedPath string) FieldSort

NestedPath is used if sorting occurs on a field that is inside a nested object.

func (FieldSort) Order 

func (s FieldSort) Order(ascending bool) FieldSort

Order defines whether sorting ascending (default) or descending.

func (FieldSort) SortMode 

func (s FieldSort) SortMode(sortMode string) FieldSort

SortMode specifies what values to pick in case a document contains multiple values for the targeted sort field. Possible values are: min, max, sum, and avg.

func (FieldSort) Source 

func (s FieldSort) Source() interface{}

Source returns the JSON-serializable data.

func (FieldSort) UnmappedType 

func (s FieldSort) UnmappedType(typ string) FieldSort

UnmappedType sets the type to use when the current field is not mapped in an index.

type FieldStatistics 

type FieldStatistics struct {
	DocCount   int64 `json:"doc_count"`
	SumDocFreq int64 `json:"sum_doc_freq"`
	SumTtf     int64 `json:"sum_ttf"`
}

type FieldValueFactorFunction 

type FieldValueFactorFunction struct {
	// contains filtered or unexported fields
}

FieldValueFactorFunction is a function score function that allows you to use a field from a document to influence the score. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-function-score-query.html#_field_value_factor.

func NewFieldValueFactorFunction 

func NewFieldValueFactorFunction() FieldValueFactorFunction

NewFieldValueFactorFunction initializes and returns a new FieldValueFactorFunction.

func (FieldValueFactorFunction) Factor 

func (fn FieldValueFactorFunction) Factor(factor float64) FieldValueFactorFunction

Factor is the (optional) factor to multiply the field with. If you do not specify a factor, the default is 1.

func (FieldValueFactorFunction) Field 

func (fn FieldValueFactorFunction) Field(field string) FieldValueFactorFunction

Field is the field to be extracted from the document.

func (FieldValueFactorFunction) GetWeight 

func (fn FieldValueFactorFunction) GetWeight() *float64

GetWeight returns the adjusted score. It is part of the ScoreFunction interface. Returns nil if weight is not specified.

func (FieldValueFactorFunction) Missing 

func (fn FieldValueFactorFunction) Missing(missing float64) FieldValueFactorFunction

Missing is used if a document does not have that field.

func (FieldValueFactorFunction) Modifier 

func (fn FieldValueFactorFunction) Modifier(modifier string) FieldValueFactorFunction

Modifier to apply to the field value. It can be one of: none, log, log1p, log2p, ln, ln1p, ln2p, square, sqrt, or reciprocal. Defaults to: none.

func (FieldValueFactorFunction) Name 

func (fn FieldValueFactorFunction) Name() string

Name represents the JSON field name under which the output of Source needs to be serialized by FunctionScoreQuery (see FunctionScoreQuery.Source).

func (FieldValueFactorFunction) Source 

func (fn FieldValueFactorFunction) Source() interface{}

Source returns the serializable JSON data of this score function.

func (FieldValueFactorFunction) Weight 

func (fn FieldValueFactorFunction) Weight(weight float64) FieldValueFactorFunction

Weight adjusts the score of the score function. See https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-function-score-query.html#_using_function_score for details.

type Filter 

type Filter interface {
	Source() interface{}
}

type FilterAggregation 

type FilterAggregation struct {
	// contains filtered or unexported fields
}

FilterAggregation defines a single bucket of all the documents in the current document set context that match a specified filter. Often this will be used to narrow down the current aggregation context to a specific set of documents. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-filter-aggregation.html

func NewFilterAggregation 

func NewFilterAggregation() FilterAggregation

func (FilterAggregation) Filter 

func (a FilterAggregation) Filter(filter Filter) FilterAggregation

func (FilterAggregation) Source 

func (a FilterAggregation) Source() interface{}

func (FilterAggregation) SubAggregation 

func (a FilterAggregation) SubAggregation(name string, subAggregation Aggregation) FilterAggregation

type FilterFacet 

type FilterFacet struct {
	// contains filtered or unexported fields
}

A filter facet (not to be confused with a facet filter) allows you to return a count of the hits matching the filter. The filter itself can be expressed using the Query DSL. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-facets-filter-facet.html

func NewFilterFacet 

func NewFilterFacet() FilterFacet

func (FilterFacet) FacetFilter 

func (f FilterFacet) FacetFilter(filter Facet) FilterFacet

func (FilterFacet) Filter 

func (f FilterFacet) Filter(filter Filter) FilterFacet

func (FilterFacet) Global 

func (f FilterFacet) Global(global bool) FilterFacet

func (FilterFacet) Mode 

func (f FilterFacet) Mode(mode string) FilterFacet

func (FilterFacet) Nested 

func (f FilterFacet) Nested(nested string) FilterFacet

func (FilterFacet) Source 

func (f FilterFacet) Source() interface{}

type FilteredQuery 

type FilteredQuery struct {
	// contains filtered or unexported fields
}

FilteredQuery is a query that applies a filter to the results of another query. For more details, see http://www.elasticsearch.org/guide/reference/query-dsl/filtered-query.html

func NewFilteredQuery 

func NewFilteredQuery(query Query) FilteredQuery

NewFilteredQuery creates a new filtered query.

func (FilteredQuery) Boost 

func (q FilteredQuery) Boost(boost float32) FilteredQuery

func (FilteredQuery) Filter 

func (q FilteredQuery) Filter(filter Filter) FilteredQuery

func (FilteredQuery) Query 

func (q FilteredQuery) Query(query Query) FilteredQuery

func (FilteredQuery) Source 

func (q FilteredQuery) Source() interface{}

Creates the query source for the filtered query.

type FiltersAggregation 

type FiltersAggregation struct {
	// contains filtered or unexported fields
}

FiltersAggregation defines a multi bucket aggregations where each bucket is associated with a filter. Each bucket will collect all documents that match its associated filter. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-filters-aggregation.html

func NewFiltersAggregation 

func NewFiltersAggregation() FiltersAggregation

func (FiltersAggregation) Filter 

func (a FiltersAggregation) Filter(filter Filter) FiltersAggregation

func (FiltersAggregation) Filters 

func (a FiltersAggregation) Filters(filters ...Filter) FiltersAggregation

func (FiltersAggregation) Source 

func (a FiltersAggregation) Source() interface{}

func (FiltersAggregation) SubAggregation 

func (a FiltersAggregation) SubAggregation(name string, subAggregation Aggregation) FiltersAggregation

type FlushResult 

type FlushResult struct {
	Shards shardsInfo `json:"_shards"`
}

type FlushService 

type FlushService struct {
	// contains filtered or unexported fields
}

Flush allows to flush one or more indices. The flush process of an index basically frees memory from the index by flushing data to the index storage and clearing the internal transaction log.

See http://www.elastic.co/guide/en/elasticsearch/reference/current/indices-flush.html for details.

func NewFlushService 

func NewFlushService(client *Client) *FlushService

func (*FlushService) AllowNoIndices 

func (s *FlushService) AllowNoIndices(allowNoIndices bool) *FlushService

AllowNoIndices specifies whether to ignore if a wildcard expression yields no indices. This includes the _all index or when no indices have been specified.

func (*FlushService) Do 

func (s *FlushService) Do() (*FlushResult, error)

Do executes the service.

func (*FlushService) ExpandWildcards 

func (s *FlushService) ExpandWildcards(expandWildcards string) *FlushService

ExpandWildcards specifies whether to expand wildcards to concrete indices that are open, closed, or both. Use one of "open", "closed", "none", or "all".

func (*FlushService) Force 

func (s *FlushService) Force(force bool) *FlushService

Force specifies whether to force a flush even if it is not necessary.

func (*FlushService) Full 

func (s *FlushService) Full(full bool) *FlushService

Full, when set to true, creates a new index writer for the index and refreshes all settings related to the index.

func (*FlushService) IgnoreUnavailable 

func (s *FlushService) IgnoreUnavailable(ignoreUnavailable bool) *FlushService

IgnoreUnavailable specifies whether concrete indices should be ignored when unavailable (e.g. missing or closed).

func (*FlushService) Index 

func (s *FlushService) Index(index string) *FlushService

func (*FlushService) Indices 

func (s *FlushService) Indices(indices ...string) *FlushService

func (*FlushService) WaitIfOngoing 

func (s *FlushService) WaitIfOngoing(wait bool) *FlushService

WaitIfOngoing will block until the flush can be executed (if set to true) if another flush operation is already executing. The default is false and will cause an exception to be thrown on the shard level if another flush operation is already running. [1.4.0.Beta1]

type FunctionScoreQuery 

type FunctionScoreQuery struct {
	// contains filtered or unexported fields
}

The function_score allows you to modify the score of documents that are retrieved by a query. This can be useful if, for example, a score function is computationally expensive and it is sufficient to compute the score on a filtered set of documents. For more details, see http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-function-score-query.html

func NewFunctionScoreQuery 

func NewFunctionScoreQuery() FunctionScoreQuery

NewFunctionScoreQuery creates a new function score query.

func (FunctionScoreQuery) Add 

func (q FunctionScoreQuery) Add(filter Filter, scoreFunc ScoreFunction) FunctionScoreQuery

func (FunctionScoreQuery) AddScoreFunc 

func (q FunctionScoreQuery) AddScoreFunc(scoreFunc ScoreFunction) FunctionScoreQuery

func (FunctionScoreQuery) Boost 

func (q FunctionScoreQuery) Boost(boost float32) FunctionScoreQuery

func (FunctionScoreQuery) BoostMode 

func (q FunctionScoreQuery) BoostMode(boostMode string) FunctionScoreQuery

func (FunctionScoreQuery) Filter 

func (q FunctionScoreQuery) Filter(filter Filter) FunctionScoreQuery

func (FunctionScoreQuery) MaxBoost 

func (q FunctionScoreQuery) MaxBoost(maxBoost float32) FunctionScoreQuery

func (FunctionScoreQuery) MinScore 

func (q FunctionScoreQuery) MinScore(minScore float32) FunctionScoreQuery

func (FunctionScoreQuery) Query 

func (q FunctionScoreQuery) Query(query Query) FunctionScoreQuery

func (FunctionScoreQuery) ScoreMode 

func (q FunctionScoreQuery) ScoreMode(scoreMode string) FunctionScoreQuery

func (FunctionScoreQuery) Source 

func (q FunctionScoreQuery) Source() interface{}

Source returns JSON for the function score query.

type Fuzziness 

type Fuzziness struct {
}

Fuzziness defines the fuzziness which is used in FuzzyCompletionSuggester.

type FuzzyCompletionSuggester 

type FuzzyCompletionSuggester struct {
	Suggester
	// contains filtered or unexported fields
}

FuzzyFuzzyCompletionSuggester is a FuzzyCompletionSuggester that allows fuzzy completion. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-suggesters-completion.html for details, and http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-suggesters-completion.html#fuzzy for details about the fuzzy completion suggester.

func NewFuzzyCompletionSuggester 

func NewFuzzyCompletionSuggester(name string) FuzzyCompletionSuggester

Creates a new completion suggester.

func (FuzzyCompletionSuggester) Analyzer 

func (q FuzzyCompletionSuggester) Analyzer(analyzer string) FuzzyCompletionSuggester

func (FuzzyCompletionSuggester) ContextQueries 

func (q FuzzyCompletionSuggester) ContextQueries(queries ...SuggesterContextQuery) FuzzyCompletionSuggester

func (FuzzyCompletionSuggester) ContextQuery 

func (q FuzzyCompletionSuggester) ContextQuery(query SuggesterContextQuery) FuzzyCompletionSuggester

func (FuzzyCompletionSuggester) Field 

func (q FuzzyCompletionSuggester) Field(field string) FuzzyCompletionSuggester

func (FuzzyCompletionSuggester) Fuzziness 

func (q FuzzyCompletionSuggester) Fuzziness(fuzziness interface{}) FuzzyCompletionSuggester

Fuzziness defines the strategy used to describe what "fuzzy" actually means for the suggester, e.g. 1, 2, "0", "1..2", ">4", or "AUTO". See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/common-options.html#fuzziness for a detailed description.

func (FuzzyCompletionSuggester) FuzzyMinLength 

func (q FuzzyCompletionSuggester) FuzzyMinLength(minLength int) FuzzyCompletionSuggester

func (FuzzyCompletionSuggester) FuzzyPrefixLength 

func (q FuzzyCompletionSuggester) FuzzyPrefixLength(prefixLength int) FuzzyCompletionSuggester

func (FuzzyCompletionSuggester) FuzzyTranspositions 

func (q FuzzyCompletionSuggester) FuzzyTranspositions(fuzzyTranspositions bool) FuzzyCompletionSuggester

func (FuzzyCompletionSuggester) Name 

func (q FuzzyCompletionSuggester) Name() string

func (FuzzyCompletionSuggester) ShardSize 

func (q FuzzyCompletionSuggester) ShardSize(shardSize int) FuzzyCompletionSuggester

func (FuzzyCompletionSuggester) Size 

func (q FuzzyCompletionSuggester) Size(size int) FuzzyCompletionSuggester

func (FuzzyCompletionSuggester) Source 

func (q FuzzyCompletionSuggester) Source(includeName bool) interface{}

Creates the source for the completion suggester.

func (FuzzyCompletionSuggester) Text 

func (q FuzzyCompletionSuggester) Text(text string) FuzzyCompletionSuggester

func (FuzzyCompletionSuggester) UnicodeAware 

func (q FuzzyCompletionSuggester) UnicodeAware(unicodeAware bool) FuzzyCompletionSuggester

type FuzzyLikeThisFieldQuery 

type FuzzyLikeThisFieldQuery struct {
	Query
	// contains filtered or unexported fields
}

FuzzyLikeThisFieldQuery is the same as the fuzzy_like_this query, except that it runs against a single field. It provides nicer query DSL over the generic fuzzy_like_this query, and support typed fields query (automatically wraps typed fields with type filter to match only on the specific type). For more details, see http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-flt-field-query.html

func NewFuzzyLikeThisFieldQuery 

func NewFuzzyLikeThisFieldQuery(field string) FuzzyLikeThisFieldQuery

NewFuzzyLikeThisFieldQuery creates a new fuzzy like this field query.

func (FuzzyLikeThisFieldQuery) Analyzer 

func (q FuzzyLikeThisFieldQuery) Analyzer(analyzer string) FuzzyLikeThisFieldQuery

func (FuzzyLikeThisFieldQuery) Boost 

func (q FuzzyLikeThisFieldQuery) Boost(boost float32) FuzzyLikeThisFieldQuery

func (FuzzyLikeThisFieldQuery) FailOnUnsupportedField 

func (q FuzzyLikeThisFieldQuery) FailOnUnsupportedField(fail bool) FuzzyLikeThisFieldQuery

func (FuzzyLikeThisFieldQuery) Fuzziness 

func (q FuzzyLikeThisFieldQuery) Fuzziness(fuzziness interface{}) FuzzyLikeThisFieldQuery

Fuzziness can be an integer/long like 0, 1 or 2 as well as strings like "auto", "0..1", "1..4" or "0.0..1.0".

func (FuzzyLikeThisFieldQuery) IgnoreTF 

func (q FuzzyLikeThisFieldQuery) IgnoreTF(ignoreTF bool) FuzzyLikeThisFieldQuery

func (FuzzyLikeThisFieldQuery) LikeText 

func (q FuzzyLikeThisFieldQuery) LikeText(likeText string) FuzzyLikeThisFieldQuery

func (FuzzyLikeThisFieldQuery) MaxQueryTerms 

func (q FuzzyLikeThisFieldQuery) MaxQueryTerms(maxQueryTerms int) FuzzyLikeThisFieldQuery

func (FuzzyLikeThisFieldQuery) PrefixLength 

func (q FuzzyLikeThisFieldQuery) PrefixLength(prefixLength int) FuzzyLikeThisFieldQuery

func (FuzzyLikeThisFieldQuery) QueryName 

func (q FuzzyLikeThisFieldQuery) QueryName(queryName string) FuzzyLikeThisFieldQuery

func (FuzzyLikeThisFieldQuery) Source 

func (q FuzzyLikeThisFieldQuery) Source() interface{}

Creates the query source for the ids query.

type FuzzyLikeThisQuery 

type FuzzyLikeThisQuery struct {
	Query
	// contains filtered or unexported fields
}

FuzzyLikeThisQuery finds documents that are "like" provided text by running it against one or more fields. For more details, see http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-flt-query.html

func NewFuzzyLikeThisQuery 

func NewFuzzyLikeThisQuery() FuzzyLikeThisQuery

NewFuzzyLikeThisQuery creates a new fuzzy query.

func (FuzzyLikeThisQuery) Analyzer 

func (q FuzzyLikeThisQuery) Analyzer(analyzer string) FuzzyLikeThisQuery

func (FuzzyLikeThisQuery) Boost 

func (q FuzzyLikeThisQuery) Boost(boost float32) FuzzyLikeThisQuery

func (FuzzyLikeThisQuery) FailOnUnsupportedField 

func (q FuzzyLikeThisQuery) FailOnUnsupportedField(fail bool) FuzzyLikeThisQuery

func (FuzzyLikeThisQuery) Field 

func (q FuzzyLikeThisQuery) Field(field string) FuzzyLikeThisQuery

func (FuzzyLikeThisQuery) Fields 

func (q FuzzyLikeThisQuery) Fields(fields ...string) FuzzyLikeThisQuery

func (FuzzyLikeThisQuery) Fuzziness 

func (q FuzzyLikeThisQuery) Fuzziness(fuzziness interface{}) FuzzyLikeThisQuery

Fuzziness can be an integer/long like 0, 1 or 2 as well as strings like "auto", "0..1", "1..4" or "0.0..1.0".

func (FuzzyLikeThisQuery) IgnoreTF 

func (q FuzzyLikeThisQuery) IgnoreTF(ignoreTF bool) FuzzyLikeThisQuery

func (FuzzyLikeThisQuery) LikeText 

func (q FuzzyLikeThisQuery) LikeText(likeText string) FuzzyLikeThisQuery

func (FuzzyLikeThisQuery) MaxQueryTerms 

func (q FuzzyLikeThisQuery) MaxQueryTerms(maxQueryTerms int) FuzzyLikeThisQuery

func (FuzzyLikeThisQuery) PrefixLength 

func (q FuzzyLikeThisQuery) PrefixLength(prefixLength int) FuzzyLikeThisQuery

func (FuzzyLikeThisQuery) QueryName 

func (q FuzzyLikeThisQuery) QueryName(queryName string) FuzzyLikeThisQuery

func (FuzzyLikeThisQuery) Source 

func (q FuzzyLikeThisQuery) Source() interface{}

Creates the query source for the ids query.

type FuzzyQuery 

type FuzzyQuery struct {
	Query
	// contains filtered or unexported fields
}

FuzzyQuery uses similarity based on Levenshtein edit distance for string fields, and a +/- margin on numeric and date fields. For more details, see http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-fuzzy-query.html

func NewFuzzyQuery 

func NewFuzzyQuery() FuzzyQuery

NewFuzzyQuery creates a new fuzzy query.

func (FuzzyQuery) Boost 

func (q FuzzyQuery) Boost(boost float32) FuzzyQuery

func (FuzzyQuery) Fuzziness 

func (q FuzzyQuery) Fuzziness(fuzziness interface{}) FuzzyQuery

Fuzziness can be an integer/long like 0, 1 or 2 as well as strings like "auto", "0..1", "1..4" or "0.0..1.0".

func (FuzzyQuery) MaxExpansions 

func (q FuzzyQuery) MaxExpansions(maxExpansions int) FuzzyQuery

func (FuzzyQuery) Name 

func (q FuzzyQuery) Name(name string) FuzzyQuery

func (FuzzyQuery) PrefixLength 

func (q FuzzyQuery) PrefixLength(prefixLength int) FuzzyQuery

func (FuzzyQuery) QueryName 

func (q FuzzyQuery) QueryName(queryName string) FuzzyQuery

func (FuzzyQuery) Source 

func (q FuzzyQuery) Source() interface{}

Creates the query source for the ids query.

func (FuzzyQuery) Transpositions 

func (q FuzzyQuery) Transpositions(transpositions bool) FuzzyQuery

func (FuzzyQuery) Value 

func (q FuzzyQuery) Value(value interface{}) FuzzyQuery

type GaussDecayFunction 

type GaussDecayFunction struct {
	// contains filtered or unexported fields
}

GaussDecayFunction builds a gauss decay score function. See https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-function-score-query.html for details.

func NewGaussDecayFunction 

func NewGaussDecayFunction() GaussDecayFunction

NewGaussDecayFunction returns a new GaussDecayFunction.

func (GaussDecayFunction) Decay 

func (fn GaussDecayFunction) Decay(decay float64) GaussDecayFunction

Decay defines how documents are scored at the distance given a Scale. If no decay is defined, documents at the distance Scale will be scored 0.5.

func (GaussDecayFunction) FieldName 

func (fn GaussDecayFunction) FieldName(fieldName string) GaussDecayFunction

FieldName specifies the name of the field to which this decay function is applied to.

func (GaussDecayFunction) GetWeight 

func (fn GaussDecayFunction) GetWeight() *float64

GetWeight returns the adjusted score. It is part of the ScoreFunction interface. Returns nil if weight is not specified.

func (GaussDecayFunction) MultiValueMode 

func (fn GaussDecayFunction) MultiValueMode(mode string) GaussDecayFunction

MultiValueMode specifies how the decay function should be calculated on a field that has multiple values. Valid modes are: min, max, avg, and sum.

func (GaussDecayFunction) Name 

func (fn GaussDecayFunction) Name() string

Name represents the JSON field name under which the output of Source needs to be serialized by FunctionScoreQuery (see FunctionScoreQuery.Source).

func (GaussDecayFunction) Offset 

func (fn GaussDecayFunction) Offset(offset interface{}) GaussDecayFunction

Offset, if defined, computes the decay function only for a distance greater than the defined offset.

func (GaussDecayFunction) Origin 

func (fn GaussDecayFunction) Origin(origin interface{}) GaussDecayFunction

Origin defines the "central point" by which the decay function calculates "distance".

func (GaussDecayFunction) Scale 

func (fn GaussDecayFunction) Scale(scale interface{}) GaussDecayFunction

Scale defines the scale to be used with Decay.

func (GaussDecayFunction) Source 

func (fn GaussDecayFunction) Source() interface{}

Source returns the serializable JSON data of this score function.

func (GaussDecayFunction) Weight 

func (fn GaussDecayFunction) Weight(weight float64) GaussDecayFunction

Weight adjusts the score of the score function. See https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-function-score-query.html#_using_function_score for details.

type GeoBoundsAggregation 

type GeoBoundsAggregation struct {
	// contains filtered or unexported fields
}

GeoBoundsAggregation is a metric aggregation that computes the bounding box containing all geo_point values for a field. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-metrics-geobounds-aggregation.html

func NewGeoBoundsAggregation 

func NewGeoBoundsAggregation() GeoBoundsAggregation

func (GeoBoundsAggregation) Field 

func (a GeoBoundsAggregation) Field(field string) GeoBoundsAggregation

func (GeoBoundsAggregation) Lang 

func (a GeoBoundsAggregation) Lang(lang string) GeoBoundsAggregation

func (GeoBoundsAggregation) Param 

func (a GeoBoundsAggregation) Param(name string, value interface{}) GeoBoundsAggregation

func (GeoBoundsAggregation) Params 

func (a GeoBoundsAggregation) Params(params map[string]interface{}) GeoBoundsAggregation

func (GeoBoundsAggregation) Script 

func (a GeoBoundsAggregation) Script(script string) GeoBoundsAggregation

func (GeoBoundsAggregation) ScriptFile 

func (a GeoBoundsAggregation) ScriptFile(scriptFile string) GeoBoundsAggregation

func (GeoBoundsAggregation) Source 

func (a GeoBoundsAggregation) Source() interface{}

func (GeoBoundsAggregation) WrapLongitude 

func (a GeoBoundsAggregation) WrapLongitude(wrapLongitude bool) GeoBoundsAggregation

type GeoDistanceAggregation 

type GeoDistanceAggregation struct {
	// contains filtered or unexported fields
}

GeoDistanceAggregation is a multi-bucket aggregation that works on geo_point fields and conceptually works very similar to the range aggregation. The user can define a point of origin and a set of distance range buckets. The aggregation evaluate the distance of each document value from the origin point and determines the buckets it belongs to based on the ranges (a document belongs to a bucket if the distance between the document and the origin falls within the distance range of the bucket). See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-aggregations-bucket-geodistance-aggregation.html

func NewGeoDistanceAggregation 

func NewGeoDistanceAggregation() GeoDistanceAggregation

func (GeoDistanceAggregation) AddRange 

func (a GeoDistanceAggregation) AddRange(from, to interface{}) GeoDistanceAggregation

func (GeoDistanceAggregation) AddRangeWithKey 

func (a GeoDistanceAggregation) AddRangeWithKey(key string, from, to interface{}) GeoDistanceAggregation

func (GeoDistanceAggregation) AddUnboundedFrom 

func (a GeoDistanceAggregation) AddUnboundedFrom(to float64) GeoDistanceAggregation

func (GeoDistanceAggregation) AddUnboundedFromWithKey 

func (a GeoDistanceAggregation) AddUnboundedFromWithKey(key string, to float64) GeoDistanceAggregation

func (GeoDistanceAggregation) AddUnboundedTo 

func (a GeoDistanceAggregation) AddUnboundedTo(from float64) GeoDistanceAggregation

func (GeoDistanceAggregation) AddUnboundedToWithKey 

func (a GeoDistanceAggregation) AddUnboundedToWithKey(key string, from float64) GeoDistanceAggregation

func (GeoDistanceAggregation) Between 

func (a GeoDistanceAggregation) Between(from, to interface{}) GeoDistanceAggregation

func (GeoDistanceAggregation) BetweenWithKey 

func (a GeoDistanceAggregation) BetweenWithKey(key string, from, to interface{}) GeoDistanceAggregation

func (GeoDistanceAggregation) DistanceType 

func (a GeoDistanceAggregation) DistanceType(distanceType string) GeoDistanceAggregation

func (GeoDistanceAggregation) Field 

func (a GeoDistanceAggregation) Field(field string) GeoDistanceAggregation

func (GeoDistanceAggregation) Point 

func (a GeoDistanceAggregation) Point(latLon string) GeoDistanceAggregation

func (GeoDistanceAggregation) Source 

func (a GeoDistanceAggregation) Source() interface{}

func (GeoDistanceAggregation) SubAggregation 

func (a GeoDistanceAggregation) SubAggregation(name string, subAggregation Aggregation) GeoDistanceAggregation

func (GeoDistanceAggregation) Unit 

func (a GeoDistanceAggregation) Unit(unit string) GeoDistanceAggregation

type GeoDistanceFacet 

type GeoDistanceFacet struct {
	// contains filtered or unexported fields
}

The geo_distance facet is a facet providing information for ranges of distances from a provided geo_point including count of the number of hits that fall within each range, and aggregation information (like total). See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-facets-geo-distance-facet.html

func NewGeoDistanceFacet 

func NewGeoDistanceFacet() GeoDistanceFacet

func (GeoDistanceFacet) AddRange 

func (f GeoDistanceFacet) AddRange(from, to float64) GeoDistanceFacet

func (GeoDistanceFacet) AddUnboundedFrom 

func (f GeoDistanceFacet) AddUnboundedFrom(to float64) GeoDistanceFacet

func (GeoDistanceFacet) AddUnboundedTo 

func (f GeoDistanceFacet) AddUnboundedTo(from float64) GeoDistanceFacet

func (GeoDistanceFacet) FacetFilter 

func (f GeoDistanceFacet) FacetFilter(filter Facet) GeoDistanceFacet

func (GeoDistanceFacet) Field 

func (f GeoDistanceFacet) Field(fieldName string) GeoDistanceFacet

func (GeoDistanceFacet) GeoDistance 

func (f GeoDistanceFacet) GeoDistance(geoDistance string) GeoDistanceFacet

func (GeoDistanceFacet) GeoHash 

func (f GeoDistanceFacet) GeoHash(geoHash string) GeoDistanceFacet

func (GeoDistanceFacet) Global 

func (f GeoDistanceFacet) Global(global bool) GeoDistanceFacet

func (GeoDistanceFacet) Lang 

func (f GeoDistanceFacet) Lang(lang string) GeoDistanceFacet

func (GeoDistanceFacet) Lat 

func (f GeoDistanceFacet) Lat(lat float64) GeoDistanceFacet

func (GeoDistanceFacet) Lon 

func (f GeoDistanceFacet) Lon(lon float64) GeoDistanceFacet

func (GeoDistanceFacet) Mode 

func (f GeoDistanceFacet) Mode(mode string) GeoDistanceFacet

func (GeoDistanceFacet) Nested 

func (f GeoDistanceFacet) Nested(nested string) GeoDistanceFacet

func (GeoDistanceFacet) Point 

func (f GeoDistanceFacet) Point(lat, lon float64) GeoDistanceFacet

func (GeoDistanceFacet) ScriptParam 

func (f GeoDistanceFacet) ScriptParam(name string, value interface{}) GeoDistanceFacet

func (GeoDistanceFacet) Source 

func (f GeoDistanceFacet) Source() interface{}

func (GeoDistanceFacet) Unit 

func (f GeoDistanceFacet) Unit(distanceUnit string) GeoDistanceFacet

func (GeoDistanceFacet) ValueField 

func (f GeoDistanceFacet) ValueField(valueFieldName string) GeoDistanceFacet

func (GeoDistanceFacet) ValueScript 

func (f GeoDistanceFacet) ValueScript(valueScript string) GeoDistanceFacet

type GeoDistanceFilter 

type GeoDistanceFilter struct {
	Filter
	// contains filtered or unexported fields
}

GeoDistanceFilter filters documents that include only hits that exists within a specific distance from a geo point.

For more details, see: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-geo-distance-filter.html

func NewGeoDistanceFilter 

func NewGeoDistanceFilter(name string) GeoDistanceFilter

NewGeoDistanceFilter creates a new GeoDistanceFilter.

func (GeoDistanceFilter) Cache 

func (f GeoDistanceFilter) Cache(cache bool) GeoDistanceFilter

func (GeoDistanceFilter) CacheKey 

func (f GeoDistanceFilter) CacheKey(cacheKey string) GeoDistanceFilter

func (GeoDistanceFilter) Distance 

func (f GeoDistanceFilter) Distance(distance string) GeoDistanceFilter

func (GeoDistanceFilter) DistanceType 

func (f GeoDistanceFilter) DistanceType(distanceType string) GeoDistanceFilter

func (GeoDistanceFilter) FilterName 

func (f GeoDistanceFilter) FilterName(filterName string) GeoDistanceFilter

func (GeoDistanceFilter) GeoHash 

func (f GeoDistanceFilter) GeoHash(geohash string) GeoDistanceFilter

func (GeoDistanceFilter) GeoPoint 

func (f GeoDistanceFilter) GeoPoint(point *GeoPoint) GeoDistanceFilter

func (GeoDistanceFilter) Lat 

func (f GeoDistanceFilter) Lat(lat float64) GeoDistanceFilter

func (GeoDistanceFilter) Lon 

func (f GeoDistanceFilter) Lon(lon float64) GeoDistanceFilter

func (GeoDistanceFilter) OptimizeBbox 

func (f GeoDistanceFilter) OptimizeBbox(optimizeBbox string) GeoDistanceFilter

func (GeoDistanceFilter) Point 

func (f GeoDistanceFilter) Point(lat, lon float64) GeoDistanceFilter

func (GeoDistanceFilter) Source 

func (f GeoDistanceFilter) Source() interface{}

Creates the query source for the geo_distance filter.

type GeoDistanceSort 

type GeoDistanceSort struct {
	Sorter
	// contains filtered or unexported fields
}

GeoDistanceSort allows for sorting by geographic distance. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-sort.html#_geo_distance_sorting.

func NewGeoDistanceSort 

func NewGeoDistanceSort(fieldName string) GeoDistanceSort

NewGeoDistanceSort creates a new sorter for geo distances.

func (GeoDistanceSort) Asc 

func (s GeoDistanceSort) Asc() GeoDistanceSort

Asc sets ascending sort order.

func (GeoDistanceSort) Desc 

func (s GeoDistanceSort) Desc() GeoDistanceSort

Desc sets descending sort order.

func (GeoDistanceSort) FieldName 

func (s GeoDistanceSort) FieldName(fieldName string) GeoDistanceSort

FieldName specifies the name of the (geo) field to use for sorting.

func (GeoDistanceSort) GeoDistance 

func (s GeoDistanceSort) GeoDistance(geoDistance string) GeoDistanceSort

GeoDistance represents how to compute the distance. It can be sloppy_arc (default), arc, or plane. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-sort.html#_geo_distance_sorting.

func (GeoDistanceSort) GeoHashes 

func (s GeoDistanceSort) GeoHashes(geohashes ...string) GeoDistanceSort

GeoHashes specifies the geo point to create the range distance facets from.

func (GeoDistanceSort) NestedFilter 

func (s GeoDistanceSort) NestedFilter(nestedFilter Filter) GeoDistanceSort

NestedFilter sets a filter that nested objects should match with in order to be taken into account for sorting.

func (GeoDistanceSort) NestedPath 

func (s GeoDistanceSort) NestedPath(nestedPath string) GeoDistanceSort

NestedPath is used if sorting occurs on a field that is inside a nested object.

func (GeoDistanceSort) Order 

func (s GeoDistanceSort) Order(ascending bool) GeoDistanceSort

Order defines whether sorting ascending (default) or descending.

func (GeoDistanceSort) Point 

func (s GeoDistanceSort) Point(lat, lon float64) GeoDistanceSort

Point specifies a point to create the range distance facets from.

func (GeoDistanceSort) Points 

func (s GeoDistanceSort) Points(points ...*GeoPoint) GeoDistanceSort

Points specifies the geo point(s) to create the range distance facets from.

func (GeoDistanceSort) SortMode 

func (s GeoDistanceSort) SortMode(sortMode string) GeoDistanceSort

SortMode specifies what values to pick in case a document contains multiple values for the targeted sort field. Possible values are: min, max, sum, and avg.

func (GeoDistanceSort) Source 

func (s GeoDistanceSort) Source() interface{}

Source returns the JSON-serializable data.

func (GeoDistanceSort) Unit 

func (s GeoDistanceSort) Unit(unit string) GeoDistanceSort

Unit specifies the distance unit to use. It defaults to km. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/common-options.html#distance-units for details.

type GeoHashGridAggregation 

type GeoHashGridAggregation struct {
	// contains filtered or unexported fields
}

func NewGeoHashGridAggregation 

func NewGeoHashGridAggregation() *GeoHashGridAggregation

func (*GeoHashGridAggregation) Field 

func (a *GeoHashGridAggregation) Field(field string) *GeoHashGridAggregation

func (*GeoHashGridAggregation) Meta 

func (a *GeoHashGridAggregation) Meta(metaData map[string]interface{}) *GeoHashGridAggregation

func (*GeoHashGridAggregation) Precision 

func (a *GeoHashGridAggregation) Precision(precision int) *GeoHashGridAggregation

func (*GeoHashGridAggregation) ShardSize 

func (a *GeoHashGridAggregation) ShardSize(shardSize int) *GeoHashGridAggregation

func (*GeoHashGridAggregation) Size 

func (a *GeoHashGridAggregation) Size(size int) *GeoHashGridAggregation

func (*GeoHashGridAggregation) Source 

func (a *GeoHashGridAggregation) Source() interface{}

func (*GeoHashGridAggregation) SubAggregation 

func (a *GeoHashGridAggregation) SubAggregation(name string, subAggregation Aggregation) *GeoHashGridAggregation

type GeoPoint 

type GeoPoint struct {
	Lat, Lon float64
}

GeoPoint is a geographic position described via latitude and longitude.

func GeoPointFromLatLon 

func GeoPointFromLatLon(lat, lon float64) *GeoPoint

GeoPointFromLatLon initializes a new GeoPoint by latitude and longitude.

func GeoPointFromString 

func GeoPointFromString(latLon string) (*GeoPoint, error)

GeoPointFromString initializes a new GeoPoint by a string that is formatted as "{latitude},{longitude}", e.g. "40.10210,-70.12091".

func (*GeoPoint) Source 

func (pt *GeoPoint) Source() map[string]float64

Source returns the object to be serialized in Elasticsearch DSL.

type GeoPolygonFilter 

type GeoPolygonFilter struct {
	Filter
	// contains filtered or unexported fields
}

A filter allowing to include hits that only fall within a polygon of points. For details, see: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-geo-polygon-filter.html

func NewGeoPolygonFilter 

func NewGeoPolygonFilter(name string) GeoPolygonFilter

func (GeoPolygonFilter) AddPoint 

func (f GeoPolygonFilter) AddPoint(point *GeoPoint) GeoPolygonFilter

func (GeoPolygonFilter) Cache 

func (f GeoPolygonFilter) Cache(cache bool) GeoPolygonFilter

func (GeoPolygonFilter) CacheKey 

func (f GeoPolygonFilter) CacheKey(cacheKey string) GeoPolygonFilter

func (GeoPolygonFilter) FilterName 

func (f GeoPolygonFilter) FilterName(filterName string) GeoPolygonFilter

func (GeoPolygonFilter) Source 

func (f GeoPolygonFilter) Source() interface{}

type GetMappingService 

type GetMappingService struct {
	// contains filtered or unexported fields
}

GetMappingService retrieves the mapping definitions for an index or index/type.

See https://www.elastic.co/guide/en/elasticsearch/reference/1.7/indices-get-mapping.html for details.

func NewGetMappingService 

func NewGetMappingService(client *Client) *GetMappingService

NewGetMappingService creates a new GetMappingService.

func (*GetMappingService) AllowNoIndices 

func (s *GetMappingService) AllowNoIndices(allowNoIndices bool) *GetMappingService

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 (*GetMappingService) Do 

func (s *GetMappingService) Do() (map[string]interface{}, error)

Do executes the operation.

func (*GetMappingService) ExpandWildcards 

func (s *GetMappingService) ExpandWildcards(expandWildcards string) *GetMappingService

ExpandWildcards indicates whether to expand wildcard expression to concrete indices that are open, closed or both..

func (*GetMappingService) IgnoreUnavailable 

func (s *GetMappingService) IgnoreUnavailable(ignoreUnavailable bool) *GetMappingService

IgnoreUnavailable indicates whether specified concrete indices should be ignored when unavailable (missing or closed).

func (*GetMappingService) Index 

func (s *GetMappingService) Index(index ...string) *GetMappingService

Index is a list of index names.

func (*GetMappingService) Local 

func (s *GetMappingService) Local(local bool) *GetMappingService

Local indicates whether to return local information, do not retrieve the state from master node (default: false).

func (*GetMappingService) Pretty 

func (s *GetMappingService) Pretty(pretty bool) *GetMappingService

Pretty indicates that the JSON response be indented and human readable.

func (*GetMappingService) Type 

func (s *GetMappingService) Type(typ ...string) *GetMappingService

Type is a list of document types.

func (*GetMappingService) Validate 

func (s *GetMappingService) Validate() error

Validate checks if the operation is valid.

type GetResult 

type GetResult struct {
	Index   string                 `json:"_index"`
	Type    string                 `json:"_type"`
	Id      string                 `json:"_id"`
	Version int64                  `json:"_version,omitempty"`
	Source  *json.RawMessage       `json:"_source,omitempty"`
	Found   bool                   `json:"found,omitempty"`
	Fields  map[string]interface{} `json:"fields,omitempty"`
	Error   string                 `json:"error,omitempty"` // used only in MultiGet
}

type GetService 

type GetService struct {
	// contains filtered or unexported fields
}

func NewGetService 

func NewGetService(client *Client) *GetService

func (*GetService) Do 

func (b *GetService) Do() (*GetResult, error)

func (*GetService) FetchSource 

func (s *GetService) FetchSource(fetchSource bool) *GetService

func (*GetService) FetchSourceContext 

func (s *GetService) FetchSourceContext(fetchSourceContext *FetchSourceContext) *GetService

func (*GetService) Fields 

func (b *GetService) Fields(fields ...string) *GetService

func (*GetService) Id 

func (b *GetService) Id(id string) *GetService

func (*GetService) IgnoreErrorsOnGeneratedFields 

func (b *GetService) IgnoreErrorsOnGeneratedFields(ignore bool) *GetService

func (*GetService) Index 

func (b *GetService) Index(index string) *GetService

func (*GetService) Parent 

func (b *GetService) Parent(parent string) *GetService

func (*GetService) Preference 

func (b *GetService) Preference(preference string) *GetService

func (*GetService) Realtime 

func (b *GetService) Realtime(realtime bool) *GetService

func (*GetService) Refresh 

func (b *GetService) Refresh(refresh bool) *GetService

func (*GetService) Routing 

func (b *GetService) Routing(routing string) *GetService

func (*GetService) String 

func (b *GetService) String() string

func (*GetService) Type 

func (b *GetService) Type(typ string) *GetService

func (*GetService) Validate 

func (s *GetService) Validate() error

Validate checks if the operation is valid.

func (*GetService) Version 

func (b *GetService) Version(version int64) *GetService

func (*GetService) VersionType 

func (b *GetService) VersionType(versionType string) *GetService

type GetTemplateResponse 

type GetTemplateResponse struct {
	Template string `json:"template"`
}

type GetTemplateService 

type GetTemplateService struct {
	// contains filtered or unexported fields
}

GetTemplateService reads a search template. It is documented at http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html.

Example 
package main

import (
	"fmt"

	elastic "gopkg.in/olivere/elastic.v2"
)

func main() {
	client, err := elastic.NewClient()
	if err != nil {
		panic(err)
	}

	// Get template stored under "my-search-template"
	resp, err := client.GetTemplate().Id("my-search-template").Do()
	if err != nil {
		panic(err)
	}
	fmt.Printf("search template is: %q\n", resp.Template)
}

Output:

func NewGetTemplateService 

func NewGetTemplateService(client *Client) *GetTemplateService

NewGetTemplateService creates a new GetTemplateService.

func (*GetTemplateService) Do 

func (s *GetTemplateService) Do() (*GetTemplateResponse, error)

Do executes the operation and returns the template.

func (*GetTemplateService) Id 

func (s *GetTemplateService) Id(id string) *GetTemplateService

Id is the template ID.

func (*GetTemplateService) Validate 

func (s *GetTemplateService) Validate() error

Validate checks if the operation is valid.

func (*GetTemplateService) Version 

func (s *GetTemplateService) Version(version interface{}) *GetTemplateService

Version is an explicit version number for concurrency control.

func (*GetTemplateService) VersionType 

func (s *GetTemplateService) VersionType(versionType string) *GetTemplateService

VersionType is a specific version type.

type GlobalAggregation 

type GlobalAggregation struct {
	// contains filtered or unexported fields
}

GlobalAggregation defines a single bucket of all the documents within the search execution context. This context is defined by the indices and the document types you’re searching on, but is not influenced by the search query itself. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-global-aggregation.html

func NewGlobalAggregation 

func NewGlobalAggregation() GlobalAggregation

func (GlobalAggregation) Source 

func (a GlobalAggregation) Source() interface{}

func (GlobalAggregation) SubAggregation 

func (a GlobalAggregation) SubAggregation(name string, subAggregation Aggregation) GlobalAggregation

type HasChildFilter 

type HasChildFilter struct {
	// contains filtered or unexported fields
}

The has_child query works the same as the has_child filter, by automatically wrapping the filter with a constant_score (when using the default score type). For more details, see http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-has-child-query.html

func NewHasChildFilter 

func NewHasChildFilter(childType string) HasChildFilter

NewHasChildFilter creates a new has_child query.

func (HasChildFilter) Cache 

func (f HasChildFilter) Cache(cache bool) HasChildFilter

func (HasChildFilter) CacheKey 

func (f HasChildFilter) CacheKey(cacheKey string) HasChildFilter

func (HasChildFilter) Filter 

func (f HasChildFilter) Filter(filter Filter) HasChildFilter

func (HasChildFilter) FilterName 

func (f HasChildFilter) FilterName(filterName string) HasChildFilter

func (HasChildFilter) InnerHit 

func (f HasChildFilter) InnerHit(innerHit *InnerHit) HasChildFilter

func (HasChildFilter) MaxChildren 

func (f HasChildFilter) MaxChildren(maxChildren int) HasChildFilter

func (HasChildFilter) MinChildren 

func (f HasChildFilter) MinChildren(minChildren int) HasChildFilter

func (HasChildFilter) Query 

func (f HasChildFilter) Query(query Query) HasChildFilter

func (HasChildFilter) ShortCircuitCutoff 

func (f HasChildFilter) ShortCircuitCutoff(shortCircuitCutoff int) HasChildFilter

func (HasChildFilter) Source 

func (f HasChildFilter) Source() interface{}

Source returns the JSON document for the filter.

type HasChildQuery 

type HasChildQuery struct {
	// contains filtered or unexported fields
}

The has_child query works the same as the has_child filter, by automatically wrapping the filter with a constant_score (when using the default score type). For more details, see http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-has-child-query.html

func NewHasChildQuery 

func NewHasChildQuery(childType string, query Query) HasChildQuery

NewHasChildQuery creates a new has_child query.

func (HasChildQuery) Boost 

func (q HasChildQuery) Boost(boost float32) HasChildQuery

func (HasChildQuery) InnerHit 

func (q HasChildQuery) InnerHit(innerHit *InnerHit) HasChildQuery

func (HasChildQuery) MaxChildren 

func (q HasChildQuery) MaxChildren(maxChildren int) HasChildQuery

func (HasChildQuery) MinChildren 

func (q HasChildQuery) MinChildren(minChildren int) HasChildQuery

func (HasChildQuery) QueryName 

func (q HasChildQuery) QueryName(queryName string) HasChildQuery

func (HasChildQuery) ScoreType 

func (q HasChildQuery) ScoreType(scoreType string) HasChildQuery

func (HasChildQuery) ShortCircuitCutoff 

func (q HasChildQuery) ShortCircuitCutoff(shortCircuitCutoff int) HasChildQuery

func (HasChildQuery) Source 

func (q HasChildQuery) Source() interface{}

Creates the query source for the ids query.

type HasParentFilter 

type HasParentFilter struct {
	// contains filtered or unexported fields
}

The has_parent filter accepts a query and a parent type. The query is executed in the parent document space, which is specified by the parent type. This filter return child documents which associated parents have matched. For more details, see http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-has-parent-filter.html

func NewHasParentFilter 

func NewHasParentFilter(parentType string) HasParentFilter

NewHasParentFilter creates a new has_parent filter.

func (HasParentFilter) Cache 

func (f HasParentFilter) Cache(cache bool) HasParentFilter

func (HasParentFilter) CacheKey 

func (f HasParentFilter) CacheKey(cacheKey string) HasParentFilter

func (HasParentFilter) Filter 

func (f HasParentFilter) Filter(filter Filter) HasParentFilter

func (HasParentFilter) FilterName 

func (f HasParentFilter) FilterName(filterName string) HasParentFilter

func (HasParentFilter) InnerHit 

func (f HasParentFilter) InnerHit(innerHit *InnerHit) HasParentFilter

func (HasParentFilter) Query 

func (f HasParentFilter) Query(query Query) HasParentFilter

func (HasParentFilter) Source 

func (f HasParentFilter) Source() interface{}

Source returns the JSON document for the filter.

type HasParentQuery 

type HasParentQuery struct {
	// contains filtered or unexported fields
}

The has_parent query works the same as the has_parent filter, by automatically wrapping the filter with a constant_score (when using the default score type). It has the same syntax as the has_parent filter. For more details, see http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-has-parent-query.html

func NewHasParentQuery 

func NewHasParentQuery(parentType string, query Query) HasParentQuery

NewHasParentQuery creates a new has_parent query.

func (HasParentQuery) Boost 

func (q HasParentQuery) Boost(boost float32) HasParentQuery

func (HasParentQuery) InnerHit 

func (q HasParentQuery) InnerHit(innerHit *InnerHit) HasParentQuery

func (HasParentQuery) QueryName 

func (q HasParentQuery) QueryName(queryName string) HasParentQuery

func (HasParentQuery) ScoreType 

func (q HasParentQuery) ScoreType(scoreType string) HasParentQuery

func (HasParentQuery) Source 

func (q HasParentQuery) Source() interface{}

Creates the query source for the ids query.

type Highlight 

type Highlight struct {
	// contains filtered or unexported fields
}

Highlight allows highlighting search results on one or more fields. For details, see: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-highlighting.html

func NewHighlight 

func NewHighlight() *Highlight

func (*Highlight) BoundaryChars 

func (hl *Highlight) BoundaryChars(boundaryChars ...rune) *Highlight

func (*Highlight) BoundaryMaxScan 

func (hl *Highlight) BoundaryMaxScan(boundaryMaxScan int) *Highlight

func (*Highlight) Encoder 

func (hl *Highlight) Encoder(encoder string) *Highlight

func (*Highlight) Field 

func (hl *Highlight) Field(name string) *Highlight

func (*Highlight) Fields 

func (hl *Highlight) Fields(fields ...*HighlighterField) *Highlight

func (*Highlight) ForceSource 

func (hl *Highlight) ForceSource(forceSource bool) *Highlight

func (*Highlight) FragmentSize 

func (hl *Highlight) FragmentSize(fragmentSize int) *Highlight

func (*Highlight) Fragmenter 

func (hl *Highlight) Fragmenter(fragmenter string) *Highlight

func (*Highlight) HighlighQuery 

func (hl *Highlight) HighlighQuery(highlightQuery Query) *Highlight

func (*Highlight) HighlightFilter 

func (hl *Highlight) HighlightFilter(highlightFilter bool) *Highlight

func (*Highlight) HighlighterType 

func (hl *Highlight) HighlighterType(highlighterType string) *Highlight

func (*Highlight) NoMatchSize 

func (hl *Highlight) NoMatchSize(noMatchSize int) *Highlight

func (*Highlight) NumOfFragments 

func (hl *Highlight) NumOfFragments(numOfFragments int) *Highlight

func (*Highlight) Options 

func (hl *Highlight) Options(options map[string]interface{}) *Highlight

func (*Highlight) Order 

func (hl *Highlight) Order(order string) *Highlight

func (*Highlight) PostTags 

func (hl *Highlight) PostTags(postTags ...string) *Highlight

func (*Highlight) PreTags 

func (hl *Highlight) PreTags(preTags ...string) *Highlight

func (*Highlight) RequireFieldMatch 

func (hl *Highlight) RequireFieldMatch(requireFieldMatch bool) *Highlight

func (*Highlight) Source 

func (hl *Highlight) Source() interface{}

Creates the query source for the bool query.

func (*Highlight) TagsSchema 

func (hl *Highlight) TagsSchema(schemaName string) *Highlight

func (*Highlight) UseExplicitFieldOrder 

func (hl *Highlight) UseExplicitFieldOrder(useExplicitFieldOrder bool) *Highlight

type HighlighterField 

type HighlighterField struct {
	Name string
	// contains filtered or unexported fields
}

HighlighterField specifies a highlighted field.

func NewHighlighterField 

func NewHighlighterField(name string) *HighlighterField

func (*HighlighterField) BoundaryChars 

func (f *HighlighterField) BoundaryChars(boundaryChars ...rune) *HighlighterField

func (*HighlighterField) BoundaryMaxScan 

func (f *HighlighterField) BoundaryMaxScan(boundaryMaxScan int) *HighlighterField

func (*HighlighterField) ForceSource 

func (f *HighlighterField) ForceSource(forceSource bool) *HighlighterField

func (*HighlighterField) FragmentOffset 

func (f *HighlighterField) FragmentOffset(fragmentOffset int) *HighlighterField

func (*HighlighterField) FragmentSize 

func (f *HighlighterField) FragmentSize(fragmentSize int) *HighlighterField

func (*HighlighterField) Fragmenter 

func (f *HighlighterField) Fragmenter(fragmenter string) *HighlighterField

func (*HighlighterField) HighlightFilter 

func (f *HighlighterField) HighlightFilter(highlightFilter bool) *HighlighterField

func (*HighlighterField) HighlightQuery 

func (f *HighlighterField) HighlightQuery(highlightQuery Query) *HighlighterField

func (*HighlighterField) HighlighterType 

func (f *HighlighterField) HighlighterType(highlighterType string) *HighlighterField

func (*HighlighterField) MatchedFields 

func (f *HighlighterField) MatchedFields(matchedFields ...string) *HighlighterField

func (*HighlighterField) NoMatchSize 

func (f *HighlighterField) NoMatchSize(noMatchSize int) *HighlighterField

func (*HighlighterField) NumOfFragments 

func (f *HighlighterField) NumOfFragments(numOfFragments int) *HighlighterField

func (*HighlighterField) Options 

func (f *HighlighterField) Options(options map[string]interface{}) *HighlighterField

func (*HighlighterField) Order 

func (f *HighlighterField) Order(order string) *HighlighterField

func (*HighlighterField) PhraseLimit 

func (f *HighlighterField) PhraseLimit(phraseLimit int) *HighlighterField

func (*HighlighterField) PostTags 

func (f *HighlighterField) PostTags(postTags ...string) *HighlighterField

func (*HighlighterField) PreTags 

func (f *HighlighterField) PreTags(preTags ...string) *HighlighterField

func (*HighlighterField) RequireFieldMatch 

func (f *HighlighterField) RequireFieldMatch(requireFieldMatch bool) *HighlighterField

func (*HighlighterField) Source 

func (f *HighlighterField) Source() interface{}

type HistogramAggregation 

type HistogramAggregation struct {
	// contains filtered or unexported fields
}

HistogramAggregation is a multi-bucket values source based aggregation that can be applied on numeric values extracted from the documents. It dynamically builds fixed size (a.k.a. interval) buckets over the values. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-histogram-aggregation.html

func NewHistogramAggregation 

func NewHistogramAggregation() HistogramAggregation

func (HistogramAggregation) ExtendedBoundsMax 

func (a HistogramAggregation) ExtendedBoundsMax(max int64) HistogramAggregation

func (HistogramAggregation) ExtendedBoundsMin 

func (a HistogramAggregation) ExtendedBoundsMin(min int64) HistogramAggregation

func (HistogramAggregation) Field 

func (a HistogramAggregation) Field(field string) HistogramAggregation

func (HistogramAggregation) Interval 

func (a HistogramAggregation) Interval(interval int64) HistogramAggregation

func (HistogramAggregation) Lang 

func (a HistogramAggregation) Lang(lang string) HistogramAggregation

func (HistogramAggregation) MinDocCount 

func (a HistogramAggregation) MinDocCount(minDocCount int64) HistogramAggregation

func (HistogramAggregation) Order 

func (a HistogramAggregation) Order(order string, asc bool) HistogramAggregation

Order specifies the sort order. Valid values for order are: "_key", "_count", a sub-aggregation name, or a sub-aggregation name with a metric.

func (HistogramAggregation) OrderByAggregation 

func (a HistogramAggregation) OrderByAggregation(aggName string, asc bool) HistogramAggregation

OrderByAggregation creates a bucket ordering strategy which sorts buckets based on a single-valued calc get.

func (HistogramAggregation) OrderByAggregationAndMetric 

func (a HistogramAggregation) OrderByAggregationAndMetric(aggName, metric string, asc bool) HistogramAggregation

OrderByAggregationAndMetric creates a bucket ordering strategy which sorts buckets based on a multi-valued calc get.

func (HistogramAggregation) OrderByCount 

func (a HistogramAggregation) OrderByCount(asc bool) HistogramAggregation

func (HistogramAggregation) OrderByCountAsc 

func (a HistogramAggregation) OrderByCountAsc() HistogramAggregation

func (HistogramAggregation) OrderByCountDesc 

func (a HistogramAggregation) OrderByCountDesc() HistogramAggregation

func (HistogramAggregation) OrderByKey 

func (a HistogramAggregation) OrderByKey(asc bool) HistogramAggregation

func (HistogramAggregation) OrderByKeyAsc 

func (a HistogramAggregation) OrderByKeyAsc() HistogramAggregation

func (HistogramAggregation) OrderByKeyDesc 

func (a HistogramAggregation) OrderByKeyDesc() HistogramAggregation

func (HistogramAggregation) Param 

func (a HistogramAggregation) Param(name string, value interface{}) HistogramAggregation

func (HistogramAggregation) Script 

func (a HistogramAggregation) Script(script string) HistogramAggregation

func (HistogramAggregation) ScriptFile 

func (a HistogramAggregation) ScriptFile(scriptFile string) HistogramAggregation

func (HistogramAggregation) Source 

func (a HistogramAggregation) Source() interface{}

func (HistogramAggregation) SubAggregation 

func (a HistogramAggregation) SubAggregation(name string, subAggregation Aggregation) HistogramAggregation

type HistogramFacet 

type HistogramFacet struct {
	// contains filtered or unexported fields
}

Histogram Facet See: http://www.elasticsearch.org/guide/reference/api/search/facets/histogram-facet.html

func NewHistogramFacet 

func NewHistogramFacet() HistogramFacet

func (HistogramFacet) FacetFilter 

func (f HistogramFacet) FacetFilter(filter Facet) HistogramFacet

func (HistogramFacet) Field 

func (f HistogramFacet) Field(field string) HistogramFacet

func (HistogramFacet) Global 

func (f HistogramFacet) Global(global bool) HistogramFacet

func (HistogramFacet) Interval 

func (f HistogramFacet) Interval(interval int64) HistogramFacet

func (HistogramFacet) KeyField 

func (f HistogramFacet) KeyField(keyField string) HistogramFacet

func (HistogramFacet) Mode 

func (f HistogramFacet) Mode(mode string) HistogramFacet

func (HistogramFacet) Nested 

func (f HistogramFacet) Nested(nested string) HistogramFacet

func (HistogramFacet) Source 

func (f HistogramFacet) Source() interface{}

func (HistogramFacet) TimeInterval 

func (f HistogramFacet) TimeInterval(timeInterval string) HistogramFacet

func (HistogramFacet) ValueField 

func (f HistogramFacet) ValueField(valueField string) HistogramFacet

type HistogramScriptFacet 

type HistogramScriptFacet struct {
	// contains filtered or unexported fields
}

Histogram Facet See: http://www.elasticsearch.org/guide/reference/api/search/facets/histogram-facet.html

func NewHistogramScriptFacet 

func NewHistogramScriptFacet() HistogramScriptFacet

func (HistogramScriptFacet) Comparator 

func (f HistogramScriptFacet) Comparator(comparatorType string) HistogramScriptFacet

func (HistogramScriptFacet) FacetFilter 

func (f HistogramScriptFacet) FacetFilter(filter Facet) HistogramScriptFacet

func (HistogramScriptFacet) Global 

func (f HistogramScriptFacet) Global(global bool) HistogramScriptFacet

func (HistogramScriptFacet) Interval 

func (f HistogramScriptFacet) Interval(interval int64) HistogramScriptFacet

func (HistogramScriptFacet) KeyField 

func (f HistogramScriptFacet) KeyField(keyField string) HistogramScriptFacet

func (HistogramScriptFacet) KeyScript 

func (f HistogramScriptFacet) KeyScript(keyScript string) HistogramScriptFacet

func (HistogramScriptFacet) Mode 

func (f HistogramScriptFacet) Mode(mode string) HistogramScriptFacet

func (HistogramScriptFacet) Nested 

func (f HistogramScriptFacet) Nested(nested string) HistogramScriptFacet

func (HistogramScriptFacet) Param 

func (f HistogramScriptFacet) Param(name string, value interface{}) HistogramScriptFacet

func (HistogramScriptFacet) Source 

func (f HistogramScriptFacet) Source() interface{}

func (HistogramScriptFacet) ValueScript 

func (f HistogramScriptFacet) ValueScript(valueScript string) HistogramScriptFacet

type IdsFilter 

type IdsFilter struct {
	Filter
	// contains filtered or unexported fields
}

Filters documents that only have the provided ids. Note, this filter does not require the _id field to be indexed since it works using the _uid field. For details, see: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-ids-filter.html

func NewIdsFilter 

func NewIdsFilter(types ...string) IdsFilter

func (IdsFilter) FilterName 

func (f IdsFilter) FilterName(filterName string) IdsFilter

func (IdsFilter) Ids 

func (f IdsFilter) Ids(ids ...string) IdsFilter

func (IdsFilter) Source 

func (f IdsFilter) Source() interface{}

type IdsQuery 

type IdsQuery struct {
	Query
	// contains filtered or unexported fields
}

Filters documents that only have the provided ids. Note, this filter does not require the _id field to be indexed since it works using the _uid field. For more details, see http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-ids-query.html

func NewIdsQuery 

func NewIdsQuery(types ...string) IdsQuery

NewIdsQuery creates a new ids query.

func (IdsQuery) Boost 

func (q IdsQuery) Boost(boost float32) IdsQuery

func (IdsQuery) Ids 

func (q IdsQuery) Ids(ids ...string) IdsQuery

func (IdsQuery) QueryName 

func (q IdsQuery) QueryName(queryName string) IdsQuery

func (IdsQuery) Source 

func (q IdsQuery) Source() interface{}

Creates the query source for the ids query.

type IndexDeleteByQueryResult 

type IndexDeleteByQueryResult struct {
	Shards shardsInfo `json:"_shards"`
}

IndexDeleteByQueryResult is the result of a delete-by-query for a specific index.

type IndexExistsService 

type IndexExistsService struct {
	// contains filtered or unexported fields
}
Example 
package main

import (
	elastic "gopkg.in/olivere/elastic.v2"
)

func main() {
	// Get a client to the local Elasticsearch instance.
	client, err := elastic.NewClient()
	if err != nil {
		// Handle error
		panic(err)
	}
	// Use the IndexExists service to check if the index "twitter" exists.
	exists, err := client.IndexExists("twitter").Do()
	if err != nil {
		// Handle error
		panic(err)
	}
	if exists {
		// ...
	}
}

Output:

func NewIndexExistsService 

func NewIndexExistsService(client *Client) *IndexExistsService

func (*IndexExistsService) Do 

func (b *IndexExistsService) Do() (bool, error)

func (*IndexExistsService) Index 

func (b *IndexExistsService) Index(index string) *IndexExistsService

type IndexResult 

type IndexResult struct {
	Index   string `json:"_index"`
	Type    string `json:"_type"`
	Id      string `json:"_id"`
	Version int    `json:"_version"`
	Created bool   `json:"created"`
}

IndexResult is the result of indexing a document in Elasticsearch.

type IndexService 

type IndexService struct {
	// contains filtered or unexported fields
}

IndexService adds documents to Elasticsearch.

func NewIndexService 

func NewIndexService(client *Client) *IndexService

func (*IndexService) BodyJson 

func (b *IndexService) BodyJson(json interface{}) *IndexService

func (*IndexService) BodyString 

func (b *IndexService) BodyString(body string) *IndexService

func (*IndexService) Do 

func (b *IndexService) Do() (*IndexResult, error)

func (*IndexService) Id 

func (b *IndexService) Id(id string) *IndexService

func (*IndexService) Index 

func (b *IndexService) Index(name string) *IndexService

func (*IndexService) OpType 

func (b *IndexService) OpType(opType string) *IndexService

OpType is either "create" or "index" (the default).

func (*IndexService) Parent 

func (b *IndexService) Parent(parent string) *IndexService

func (*IndexService) Pretty 

func (b *IndexService) Pretty(pretty bool) *IndexService

func (*IndexService) Refresh 

func (b *IndexService) Refresh(refresh bool) *IndexService

func (*IndexService) Routing 

func (b *IndexService) Routing(routing string) *IndexService

func (*IndexService) TTL 

func (b *IndexService) TTL(ttl string) *IndexService

func (*IndexService) Timeout 

func (b *IndexService) Timeout(timeout string) *IndexService

func (*IndexService) Timestamp 

func (b *IndexService) Timestamp(timestamp string) *IndexService

func (*IndexService) Type 

func (b *IndexService) Type(_type string) *IndexService

func (*IndexService) Version 

func (b *IndexService) Version(version int64) *IndexService

func (*IndexService) VersionType 

func (b *IndexService) VersionType(versionType string) *IndexService

VersionType is either "internal" (default), "external", "external_gt", "external_gte", or "force". See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-index_.html#_version_types for details.

type IndexStats 

type IndexStats struct {
	Primaries *IndexStatsDetails `json:"primaries,omitempty"`
	Total     *IndexStatsDetails `json:"total,omitempty"`
}

IndexStats is index stats for a specific index.

type IndexStatsCompletion 

type IndexStatsCompletion struct {
	Size        string `json:"size,omitempty"`
	SizeInBytes int64  `json:"size_in_bytes,omitempty"`
}

type IndexStatsDetails 

type IndexStatsDetails struct {
	Docs        *IndexStatsDocs        `json:"docs,omitempty"`
	Store       *IndexStatsStore       `json:"store,omitempty"`
	Indexing    *IndexStatsIndexing    `json:"indexing,omitempty"`
	Get         *IndexStatsGet         `json:"get,omitempty"`
	Search      *IndexStatsSearch      `json:"search,omitempty"`
	Merges      *IndexStatsMerges      `json:"merges,omitempty"`
	Refresh     *IndexStatsRefresh     `json:"refresh,omitempty"`
	Flush       *IndexStatsFlush       `json:"flush,omitempty"`
	Warmer      *IndexStatsWarmer      `json:"warmer,omitempty"`
	FilterCache *IndexStatsFilterCache `json:"filter_cache,omitempty"`
	IdCache     *IndexStatsIdCache     `json:"id_cache,omitempty"`
	Fielddata   *IndexStatsFielddata   `json:"fielddata,omitempty"`
	Percolate   *IndexStatsPercolate   `json:"percolate,omitempty"`
	Completion  *IndexStatsCompletion  `json:"completion,omitempty"`
	Segments    *IndexStatsSegments    `json:"segments,omitempty"`
	Translog    *IndexStatsTranslog    `json:"translog,omitempty"`
	Suggest     *IndexStatsSuggest     `json:"suggest,omitempty"`
	QueryCache  *IndexStatsQueryCache  `json:"query_cache,omitempty"`
}

type IndexStatsDocs 

type IndexStatsDocs struct {
	Count   int64 `json:"count,omitempty"`
	Deleted int64 `json:"deleted,omitempty"`
}

type IndexStatsFielddata 

type IndexStatsFielddata struct {
	MemorySize        string `json:"memory_size,omitempty"`
	MemorySizeInBytes int64  `json:"memory_size_in_bytes,omitempty"`
	Evictions         int64  `json:"evictions,omitempty"`
}

type IndexStatsFilterCache 

type IndexStatsFilterCache struct {
	MemorySize        string `json:"memory_size,omitempty"`
	MemorySizeInBytes int64  `json:"memory_size_in_bytes,omitempty"`
	Evictions         int64  `json:"evictions,omitempty"`
}

type IndexStatsFlush 

type IndexStatsFlush struct {
	Total             int64  `json:"total,omitempty"`
	TotalTime         string `json:"total_time,omitempty"`
	TotalTimeInMillis int64  `json:"total_time_in_millis,omitempty"`
}

type IndexStatsGet 

type IndexStatsGet struct {
	Total               int64  `json:"total,omitempty"`
	GetTime             string `json:"get_time,omitempty"`
	TimeInMillis        int64  `json:"time_in_millis,omitempty"`
	ExistsTotal         int64  `json:"exists_total,omitempty"`
	ExistsTime          string `json:"exists_time,omitempty"`
	ExistsTimeInMillis  int64  `json:"exists_time_in_millis,omitempty"`
	MissingTotal        int64  `json:"missing_total,omitempty"`
	MissingTime         string `json:"missing_time,omitempty"`
	MissingTimeInMillis int64  `json:"missing_time_in_millis,omitempty"`
	Current             int64  `json:"current,omitempty"`
}

type IndexStatsIdCache 

type IndexStatsIdCache struct {
	MemorySize        string `json:"memory_size,omitempty"`
	MemorySizeInBytes int64  `json:"memory_size_in_bytes,omitempty"`
}

type IndexStatsIndexing 

type IndexStatsIndexing struct {
	IndexTotal           int64  `json:"index_total,omitempty"`
	IndexTime            string `json:"index_time,omitempty"`
	IndexTimeInMillis    int64  `json:"index_time_in_millis,omitempty"`
	IndexCurrent         int64  `json:"index_current,omitempty"`
	DeleteTotal          int64  `json:"delete_total,omitempty"`
	DeleteTime           string `json:"delete_time,omitempty"`
	DeleteTimeInMillis   int64  `json:"delete_time_in_millis,omitempty"`
	DeleteCurrent        int64  `json:"delete_current,omitempty"`
	NoopUpdateTotal      int64  `json:"noop_update_total,omitempty"`
	IsThrottled          bool   `json:"is_throttled,omitempty"`
	ThrottleTime         string `json:"throttle_time,omitempty"`
	ThrottleTimeInMillis int64  `json:"throttle_time_in_millis,omitempty"`
}

type IndexStatsMerges 

type IndexStatsMerges struct {
	Current            int64  `json:"current,omitempty"`
	CurrentDocs        int64  `json:"current_docs,omitempty"`
	CurrentSize        string `json:"current_size,omitempty"`
	CurrentSizeInBytes int64  `json:"current_size_in_bytes,omitempty"`
	Total              int64  `json:"total,omitempty"`
	TotalTime          string `json:"total_time,omitempty"`
	TotalTimeInMillis  int64  `json:"total_time_in_millis,omitempty"`
	TotalDocs          int64  `json:"total_docs,omitempty"`
	TotalSize          string `json:"total_size,omitempty"`
	TotalSizeInBytes   int64  `json:"total_size_in_bytes,omitempty"`
}

type IndexStatsPercolate 

type IndexStatsPercolate struct {
	Total             int64  `json:"total,omitempty"`
	GetTime           string `json:"get_time,omitempty"`
	TimeInMillis      int64  `json:"time_in_millis,omitempty"`
	Current           int64  `json:"current,omitempty"`
	MemorySize        string `json:"memory_size,omitempty"`
	MemorySizeInBytes int64  `json:"memory_size_in_bytes,omitempty"`
	Queries           int64  `json:"queries,omitempty"`
}

type IndexStatsQueryCache 

type IndexStatsQueryCache struct {
	MemorySize        string `json:"memory_size,omitempty"`
	MemorySizeInBytes int64  `json:"memory_size_in_bytes,omitempty"`
	Evictions         int64  `json:"evictions,omitempty"`
	HitCount          int64  `json:"hit_count,omitempty"`
	MissCount         int64  `json:"miss_count,omitempty"`
}

type IndexStatsRefresh 

type IndexStatsRefresh struct {
	Total             int64  `json:"total,omitempty"`
	TotalTime         string `json:"total_time,omitempty"`
	TotalTimeInMillis int64  `json:"total_time_in_millis,omitempty"`
}

type IndexStatsSearch 

type IndexStatsSearch struct {
	OpenContexts      int64  `json:"open_contexts,omitempty"`
	QueryTotal        int64  `json:"query_total,omitempty"`
	QueryTime         string `json:"query_time,omitempty"`
	QueryTimeInMillis int64  `json:"query_time_in_millis,omitempty"`
	QueryCurrent      int64  `json:"query_current,omitempty"`
	FetchTotal        int64  `json:"fetch_total,omitempty"`
	FetchTime         string `json:"fetch_time,omitempty"`
	FetchTimeInMillis int64  `json:"fetch_time_in_millis,omitempty"`
	FetchCurrent      int64  `json:"fetch_current,omitempty"`
}

type IndexStatsSegments 

type IndexStatsSegments struct {
	Count                       int64  `json:"count,omitempty"`
	Memory                      string `json:"memory,omitempty"`
	MemoryInBytes               int64  `json:"memory_in_bytes,omitempty"`
	IndexWriterMemory           string `json:"index_writer_memory,omitempty"`
	IndexWriterMemoryInBytes    int64  `json:"index_writer_memory_in_bytes,omitempty"`
	IndexWriterMaxMemory        string `json:"index_writer_max_memory,omitempty"`
	IndexWriterMaxMemoryInBytes int64  `json:"index_writer_max_memory_in_bytes,omitempty"`
	VersionMapMemory            string `json:"version_map_memory,omitempty"`
	VersionMapMemoryInBytes     int64  `json:"version_map_memory_in_bytes,omitempty"`
	FixedBitSetMemory           string `json:"fixed_bit_set,omitempty"`
	FixedBitSetMemoryInBytes    int64  `json:"fixed_bit_set_memory_in_bytes,omitempty"`
}

type IndexStatsStore 

type IndexStatsStore struct {
	Size                 string `json:"size,omitempty"` // human size, e.g. 119.3mb
	SizeInBytes          int64  `json:"size_in_bytes,omitempty"`
	ThrottleTime         string `json:"throttle_time,omitempty"` // human time, e.g. 0s
	ThrottleTimeInMillis int64  `json:"throttle_time_in_millis,omitempty"`
}

type IndexStatsSuggest 

type IndexStatsSuggest struct {
	Total        int64  `json:"total,omitempty"`
	Time         string `json:"time,omitempty"`
	TimeInMillis int64  `json:"time_in_millis,omitempty"`
	Current      int64  `json:"current,omitempty"`
}

type IndexStatsTranslog 

type IndexStatsTranslog struct {
	Operations  int64  `json:"operations,omitempty"`
	Size        string `json:"size,omitempty"`
	SizeInBytes int64  `json:"size_in_bytes,omitempty"`
}

type IndexStatsWarmer 

type IndexStatsWarmer struct {
	Current           int64  `json:"current,omitempty"`
	Total             int64  `json:"total,omitempty"`
	TotalTime         string `json:"total_time,omitempty"`
	TotalTimeInMillis int64  `json:"total_time_in_millis,omitempty"`
}

type IndicesDeleteTemplateResponse 

type IndicesDeleteTemplateResponse struct {
	Acknowledged bool `json:"acknowledged,omitempty"`
}

IndicesDeleteTemplateResponse is the response of IndicesDeleteTemplateService.Do.

type IndicesDeleteTemplateService 

type IndicesDeleteTemplateService struct {
	// contains filtered or unexported fields
}

IndicesDeleteTemplateService deletes index templates. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.4/indices-templates.html.

func NewIndicesDeleteTemplateService 

func NewIndicesDeleteTemplateService(client *Client) *IndicesDeleteTemplateService

NewIndicesDeleteTemplateService creates a new IndicesDeleteTemplateService.

func (*IndicesDeleteTemplateService) Do 

func (s *IndicesDeleteTemplateService) Do() (*IndicesDeleteTemplateResponse, error)

Do executes the operation.

func (*IndicesDeleteTemplateService) MasterTimeout 

func (s *IndicesDeleteTemplateService) MasterTimeout(masterTimeout string) *IndicesDeleteTemplateService

MasterTimeout specifies the timeout for connection to master.

func (*IndicesDeleteTemplateService) Name 

func (s *IndicesDeleteTemplateService) Name(name string) *IndicesDeleteTemplateService

Name is the name of the template.

func (*IndicesDeleteTemplateService) Pretty 

func (s *IndicesDeleteTemplateService) Pretty(pretty bool) *IndicesDeleteTemplateService

Pretty indicates that the JSON response be indented and human readable.

func (*IndicesDeleteTemplateService) Timeout 

func (s *IndicesDeleteTemplateService) Timeout(timeout string) *IndicesDeleteTemplateService

Timeout is an explicit operation timeout.

func (*IndicesDeleteTemplateService) Validate 

func (s *IndicesDeleteTemplateService) Validate() error

Validate checks if the operation is valid.

type IndicesDeleteWarmerService 

type IndicesDeleteWarmerService struct {
	// contains filtered or unexported fields
}

IndicesDeleteWarmerService allows to delete a warmer. See https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-warmers.html.

func NewIndicesDeleteWarmerService 

func NewIndicesDeleteWarmerService(client *Client) *IndicesDeleteWarmerService

NewIndicesDeleteWarmerService creates a new IndicesDeleteWarmerService.

func (*IndicesDeleteWarmerService) Do 

func (s *IndicesDeleteWarmerService) Do() (*DeleteWarmerResponse, error)

Do executes the operation.

func (*IndicesDeleteWarmerService) Index 

func (s *IndicesDeleteWarmerService) Index(indices ...string) *IndicesDeleteWarmerService

Index is a list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices.

func (*IndicesDeleteWarmerService) MasterTimeout 

func (s *IndicesDeleteWarmerService) MasterTimeout(masterTimeout string) *IndicesDeleteWarmerService

MasterTimeout specifies the timeout for connection to master.

func (*IndicesDeleteWarmerService) Name 

func (s *IndicesDeleteWarmerService) Name(name ...string) *IndicesDeleteWarmerService

Name is a list of warmer names to delete (supports wildcards); use `_all` to delete all warmers in the specified indices.

func (*IndicesDeleteWarmerService) Pretty 

func (s *IndicesDeleteWarmerService) Pretty(pretty bool) *IndicesDeleteWarmerService

Pretty indicates that the JSON response be indented and human readable.

func (*IndicesDeleteWarmerService) Validate 

func (s *IndicesDeleteWarmerService) Validate() error

Validate checks if the operation is valid.

type IndicesExistsTemplateService 

type IndicesExistsTemplateService struct {
	// contains filtered or unexported fields
}

IndicesExistsTemplateService checks if a given template exists. See http://www.elastic.co/guide/en/elasticsearch/reference/current/indices-templates.html#indices-templates-exists for documentation.

func NewIndicesExistsTemplateService 

func NewIndicesExistsTemplateService(client *Client) *IndicesExistsTemplateService

NewIndicesExistsTemplateService creates a new IndicesExistsTemplateService.

func (*IndicesExistsTemplateService) Do 

func (s *IndicesExistsTemplateService) Do() (bool, error)

Do executes the operation.

func (*IndicesExistsTemplateService) Local 

func (s *IndicesExistsTemplateService) Local(local bool) *IndicesExistsTemplateService

Local indicates whether to return local information, i.e. do not retrieve the state from master node (default: false).

func (*IndicesExistsTemplateService) Name 

func (s *IndicesExistsTemplateService) Name(name string) *IndicesExistsTemplateService

Name is the name of the template.

func (*IndicesExistsTemplateService) Pretty 

func (s *IndicesExistsTemplateService) Pretty(pretty bool) *IndicesExistsTemplateService

Pretty indicates that the JSON response be indented and human readable.

func (*IndicesExistsTemplateService) Validate 

func (s *IndicesExistsTemplateService) Validate() error

Validate checks if the operation is valid.

type IndicesExistsTypeService 

type IndicesExistsTypeService struct {
	// contains filtered or unexported fields
}

IndicesExistsTypeService checks if one or more types exist in one or more indices. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-types-exists.html.

func NewIndicesExistsTypeService 

func NewIndicesExistsTypeService(client *Client) *IndicesExistsTypeService

NewIndicesExistsTypeService creates a new IndicesExistsTypeService.

func (*IndicesExistsTypeService) AllowNoIndices 

func (s *IndicesExistsTypeService) AllowNoIndices(allowNoIndices bool) *IndicesExistsTypeService

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 (*IndicesExistsTypeService) Do 

func (s *IndicesExistsTypeService) Do() (bool, error)

Do executes the operation.

func (*IndicesExistsTypeService) ExpandWildcards 

func (s *IndicesExistsTypeService) ExpandWildcards(expandWildcards string) *IndicesExistsTypeService

ExpandWildcards indicates whether to expand wildcard expression to concrete indices that are open, closed or both.

func (*IndicesExistsTypeService) IgnoreUnavailable 

func (s *IndicesExistsTypeService) IgnoreUnavailable(ignoreUnavailable bool) *IndicesExistsTypeService

IgnoreUnavailable indicates whether specified concrete indices should be ignored when unavailable (missing or closed).

func (*IndicesExistsTypeService) Index 

func (s *IndicesExistsTypeService) Index(index ...string) *IndicesExistsTypeService

Index is a list of index names; use `_all` to check the types across all indices.

func (*IndicesExistsTypeService) Local 

func (s *IndicesExistsTypeService) Local(local bool) *IndicesExistsTypeService

Local specifies whether to return local information, i.e. do not retrieve the state from master node (default: false).

func (*IndicesExistsTypeService) Pretty 

func (s *IndicesExistsTypeService) Pretty(pretty bool) *IndicesExistsTypeService

Pretty indicates that the JSON response be indented and human readable.

func (*IndicesExistsTypeService) Type 

func (s *IndicesExistsTypeService) Type(typ ...string) *IndicesExistsTypeService

Type is a list of document types to check.

func (*IndicesExistsTypeService) Validate 

func (s *IndicesExistsTypeService) Validate() error

Validate checks if the operation is valid.

type IndicesGetResponse 

type IndicesGetResponse struct {
	Aliases  map[string]interface{} `json:"aliases"`
	Mappings map[string]interface{} `json:"mappings"`
	Settings map[string]interface{} `json:"settings"`
	Warmers  map[string]interface{} `json:"warmers"`
}

IndicesGetResponse is part of the response of IndicesGetService.Do.

type IndicesGetService 

type IndicesGetService struct {
	// contains filtered or unexported fields
}

IndicesGetService retrieves information about one or more indices. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-get-index.html.

func NewIndicesGetService 

func NewIndicesGetService(client *Client) *IndicesGetService

NewIndicesGetService creates a new IndicesGetService.

func (*IndicesGetService) AllowNoIndices 

func (s *IndicesGetService) AllowNoIndices(allowNoIndices bool) *IndicesGetService

AllowNoIndices indicates whether to ignore if a wildcard expression resolves to no concrete indices (default: false).

func (*IndicesGetService) Do 

func (s *IndicesGetService) Do() (map[string]*IndicesGetResponse, error)

Do executes the operation.

func (*IndicesGetService) ExpandWildcards 

func (s *IndicesGetService) ExpandWildcards(expandWildcards string) *IndicesGetService

ExpandWildcards indicates whether wildcard expressions should get expanded to open or closed indices (default: open).

func (*IndicesGetService) Feature 

func (s *IndicesGetService) Feature(feature ...string) *IndicesGetService

Feature is a list of features (e.g. _settings,_mappings,_warmers, and _aliases).

func (*IndicesGetService) IgnoreUnavailable 

func (s *IndicesGetService) IgnoreUnavailable(ignoreUnavailable bool) *IndicesGetService

IgnoreUnavailable indicates whether to ignore unavailable indexes (default: false).

func (*IndicesGetService) Index 

func (s *IndicesGetService) Index(index ...string) *IndicesGetService

Index is a list of index names. Use _all to retrieve information about all indices of a cluster.

func (*IndicesGetService) Local 

func (s *IndicesGetService) Local(local bool) *IndicesGetService

Local indicates whether to return local information (do not retrieve the state from master node (default: false)).

func (*IndicesGetService) Pretty 

func (s *IndicesGetService) Pretty(pretty bool) *IndicesGetService

Pretty indicates that the JSON response be indented and human readable.

func (*IndicesGetService) Validate 

func (s *IndicesGetService) Validate() error

Validate checks if the operation is valid.

type IndicesGetSettingsResponse 

type IndicesGetSettingsResponse struct {
	Settings map[string]interface{} `json:"settings"`
}

IndicesGetSettingsResponse is the response of IndicesGetSettingsService.Do.

type IndicesGetSettingsService 

type IndicesGetSettingsService struct {
	// contains filtered or unexported fields
}

IndicesGetSettingsService allows to retrieve settings of one or more indices. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.4/indices-get-settings.html.

func NewIndicesGetSettingsService 

func NewIndicesGetSettingsService(client *Client) *IndicesGetSettingsService

NewIndicesGetSettingsService creates a new IndicesGetSettingsService.

func (*IndicesGetSettingsService) AllowNoIndices 

func (s *IndicesGetSettingsService) AllowNoIndices(allowNoIndices bool) *IndicesGetSettingsService

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 (*IndicesGetSettingsService) Do 

func (s *IndicesGetSettingsService) Do() (map[string]*IndicesGetSettingsResponse, error)

Do executes the operation.

func (*IndicesGetSettingsService) ExpandWildcards 

func (s *IndicesGetSettingsService) ExpandWildcards(expandWildcards string) *IndicesGetSettingsService

ExpandWildcards indicates whether to expand wildcard expression to concrete indices that are open, closed or both. Options: open, closed, none, all. Default: open,closed.

func (*IndicesGetSettingsService) FlatSettings 

func (s *IndicesGetSettingsService) FlatSettings(flatSettings bool) *IndicesGetSettingsService

FlatSettings indicates whether to return settings in flat format (default: false).

func (*IndicesGetSettingsService) IgnoreUnavailable 

func (s *IndicesGetSettingsService) IgnoreUnavailable(ignoreUnavailable bool) *IndicesGetSettingsService

IgnoreUnavailable indicates whether specified concrete indices should be ignored when unavailable (missing or closed).

func (*IndicesGetSettingsService) Index 

func (s *IndicesGetSettingsService) Index(index ...string) *IndicesGetSettingsService

Index is a list of index names; use `_all` or empty string to perform the operation on all indices.

func (*IndicesGetSettingsService) Local 

func (s *IndicesGetSettingsService) Local(local bool) *IndicesGetSettingsService

Local indicates whether to return local information, do not retrieve the state from master node (default: false).

func (*IndicesGetSettingsService) Name 

func (s *IndicesGetSettingsService) Name(name ...string) *IndicesGetSettingsService

Name are the names of the settings that should be included.

func (*IndicesGetSettingsService) Pretty 

func (s *IndicesGetSettingsService) Pretty(pretty bool) *IndicesGetSettingsService

Pretty indicates that the JSON response be indented and human readable.

func (*IndicesGetSettingsService) Validate 

func (s *IndicesGetSettingsService) Validate() error

Validate checks if the operation is valid.

type IndicesGetTemplateResponse 

type IndicesGetTemplateResponse struct {
	Order    int                    `json:"order,omitempty"`
	Template string                 `json:"template,omitempty"`
	Settings map[string]interface{} `json:"settings,omitempty"`
	Mappings map[string]interface{} `json:"mappings,omitempty"`
	Aliases  map[string]interface{} `json:"aliases,omitempty"`
}

IndicesGetTemplateResponse is the response of IndicesGetTemplateService.Do.

type IndicesGetTemplateService 

type IndicesGetTemplateService struct {
	// contains filtered or unexported fields
}

IndicesGetTemplateService returns an index template. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.4/indices-templates.html.

func NewIndicesGetTemplateService 

func NewIndicesGetTemplateService(client *Client) *IndicesGetTemplateService

NewIndicesGetTemplateService creates a new IndicesGetTemplateService.

func (*IndicesGetTemplateService) Do 

func (s *IndicesGetTemplateService) Do() (map[string]*IndicesGetTemplateResponse, error)

Do executes the operation.

func (*IndicesGetTemplateService) FlatSettings 

func (s *IndicesGetTemplateService) FlatSettings(flatSettings bool) *IndicesGetTemplateService

FlatSettings is returns settings in flat format (default: false).

func (*IndicesGetTemplateService) Local 

func (s *IndicesGetTemplateService) Local(local bool) *IndicesGetTemplateService

Local indicates whether to return local information, i.e. do not retrieve the state from master node (default: false).

func (*IndicesGetTemplateService) Name 

func (s *IndicesGetTemplateService) Name(name ...string) *IndicesGetTemplateService

Name is the name of the index template.

func (*IndicesGetTemplateService) Pretty 

func (s *IndicesGetTemplateService) Pretty(pretty bool) *IndicesGetTemplateService

Pretty indicates that the JSON response be indented and human readable.

func (*IndicesGetTemplateService) Validate 

func (s *IndicesGetTemplateService) Validate() error

Validate checks if the operation is valid.

type IndicesGetWarmerService 

type IndicesGetWarmerService struct {
	// contains filtered or unexported fields
}

IndicesGetWarmerService allows to get the definition of a warmer for a specific index (or alias, or several indices) based on its name. The provided name can be a simple wildcard expression or omitted to get all warmers.

See https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-warmers.html for more information.

func NewIndicesGetWarmerService 

func NewIndicesGetWarmerService(client *Client) *IndicesGetWarmerService

NewIndicesGetWarmerService creates a new IndicesGetWarmerService.

func (*IndicesGetWarmerService) AllowNoIndices 

func (s *IndicesGetWarmerService) AllowNoIndices(allowNoIndices bool) *IndicesGetWarmerService

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 (*IndicesGetWarmerService) Do 

func (s *IndicesGetWarmerService) Do() (map[string]interface{}, error)

Do executes the operation.

func (*IndicesGetWarmerService) ExpandWildcards 

func (s *IndicesGetWarmerService) ExpandWildcards(expandWildcards string) *IndicesGetWarmerService

ExpandWildcards indicates whether to expand wildcard expression to concrete indices that are open, closed or both.

func (*IndicesGetWarmerService) IgnoreUnavailable 

func (s *IndicesGetWarmerService) IgnoreUnavailable(ignoreUnavailable bool) *IndicesGetWarmerService

IgnoreUnavailable indicates whether specified concrete indices should be ignored when unavailable (missing or closed).

func (*IndicesGetWarmerService) Index 

func (s *IndicesGetWarmerService) Index(indices ...string) *IndicesGetWarmerService

Index is a list of index names to restrict the operation; use `_all` to perform the operation on all indices.

func (*IndicesGetWarmerService) Local 

func (s *IndicesGetWarmerService) Local(local bool) *IndicesGetWarmerService

Local indicates wether or not to return local information, do not retrieve the state from master node (default: false).

func (*IndicesGetWarmerService) Name 

func (s *IndicesGetWarmerService) Name(name ...string) *IndicesGetWarmerService

Name is the name of the warmer (supports wildcards); leave empty to get all warmers.

func (*IndicesGetWarmerService) Pretty 

func (s *IndicesGetWarmerService) Pretty(pretty bool) *IndicesGetWarmerService

Pretty indicates that the JSON response be indented and human readable.

func (*IndicesGetWarmerService) Type 

func (s *IndicesGetWarmerService) Type(typ ...string) *IndicesGetWarmerService

Type is a list of type names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all types.

func (*IndicesGetWarmerService) Validate 

func (s *IndicesGetWarmerService) Validate() error

Validate checks if the operation is valid.

type IndicesPutSettingsResponse 

type IndicesPutSettingsResponse struct {
	Acknowledged bool `json:"acknowledged"`
}

IndicesPutSettingsResponse is the response of IndicesPutSettingsService.Do.

type IndicesPutSettingsService 

type IndicesPutSettingsService struct {
	// contains filtered or unexported fields
}

IndicesPutSettingsService changes specific index level settings in real time.

See the documentation at https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-update-settings.html.

func NewIndicesPutSettingsService 

func NewIndicesPutSettingsService(client *Client) *IndicesPutSettingsService

NewIndicesPutSettingsService creates a new IndicesPutSettingsService.

func (*IndicesPutSettingsService) AllowNoIndices 

func (s *IndicesPutSettingsService) AllowNoIndices(allowNoIndices bool) *IndicesPutSettingsService

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 (*IndicesPutSettingsService) BodyJson 

func (s *IndicesPutSettingsService) BodyJson(body interface{}) *IndicesPutSettingsService

BodyJson is documented as: The index settings to be updated.

func (*IndicesPutSettingsService) BodyString 

func (s *IndicesPutSettingsService) BodyString(body string) *IndicesPutSettingsService

BodyString is documented as: The index settings to be updated.

func (*IndicesPutSettingsService) Do 

func (s *IndicesPutSettingsService) Do() (*IndicesPutSettingsResponse, error)

Do executes the operation.

func (*IndicesPutSettingsService) ExpandWildcards 

func (s *IndicesPutSettingsService) ExpandWildcards(expandWildcards string) *IndicesPutSettingsService

ExpandWildcards specifies whether to expand wildcard expression to concrete indices that are open, closed or both.

func (*IndicesPutSettingsService) FlatSettings 

func (s *IndicesPutSettingsService) FlatSettings(flatSettings bool) *IndicesPutSettingsService

FlatSettings indicates whether to return settings in flat format (default: false).

func (*IndicesPutSettingsService) IgnoreUnavailable 

func (s *IndicesPutSettingsService) IgnoreUnavailable(ignoreUnavailable bool) *IndicesPutSettingsService

IgnoreUnavailable specifies whether specified concrete indices should be ignored when unavailable (missing or closed).

func (*IndicesPutSettingsService) Index 

func (s *IndicesPutSettingsService) Index(indices ...string) *IndicesPutSettingsService

Index is a list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices.

func (*IndicesPutSettingsService) MasterTimeout 

func (s *IndicesPutSettingsService) MasterTimeout(masterTimeout string) *IndicesPutSettingsService

MasterTimeout is the timeout for connection to master.

func (*IndicesPutSettingsService) Pretty 

func (s *IndicesPutSettingsService) Pretty(pretty bool) *IndicesPutSettingsService

Pretty indicates that the JSON response be indented and human readable.

func (*IndicesPutSettingsService) Validate 

func (s *IndicesPutSettingsService) Validate() error

Validate checks if the operation is valid.

type IndicesPutTemplateResponse 

type IndicesPutTemplateResponse struct {
	Acknowledged bool `json:"acknowledged,omitempty"`
}

IndicesPutTemplateResponse is the response of IndicesPutTemplateService.Do.

type IndicesPutTemplateService 

type IndicesPutTemplateService struct {
	// contains filtered or unexported fields
}

IndicesPutTemplateService creates or updates index mappings. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.4/indices-templates.html.

func NewIndicesPutTemplateService 

func NewIndicesPutTemplateService(client *Client) *IndicesPutTemplateService

NewIndicesPutTemplateService creates a new IndicesPutTemplateService.

func (*IndicesPutTemplateService) BodyJson 

func (s *IndicesPutTemplateService) BodyJson(body interface{}) *IndicesPutTemplateService

BodyJson is documented as: The template definition.

func (*IndicesPutTemplateService) BodyString 

func (s *IndicesPutTemplateService) BodyString(body string) *IndicesPutTemplateService

BodyString is documented as: The template definition.

func (*IndicesPutTemplateService) Create 

func (s *IndicesPutTemplateService) Create(create bool) *IndicesPutTemplateService

Create indicates whether the index template should only be added if new or can also replace an existing one.

func (*IndicesPutTemplateService) Do 

func (s *IndicesPutTemplateService) Do() (*IndicesPutTemplateResponse, error)

Do executes the operation.

func (*IndicesPutTemplateService) FlatSettings 

func (s *IndicesPutTemplateService) FlatSettings(flatSettings bool) *IndicesPutTemplateService

FlatSettings indicates whether to return settings in flat format (default: false).

func (*IndicesPutTemplateService) MasterTimeout 

func (s *IndicesPutTemplateService) MasterTimeout(masterTimeout string) *IndicesPutTemplateService

MasterTimeout specifies the timeout for connection to master.

func (*IndicesPutTemplateService) Name 

func (s *IndicesPutTemplateService) Name(name string) *IndicesPutTemplateService

Name is the name of the index template.

func (*IndicesPutTemplateService) Order 

func (s *IndicesPutTemplateService) Order(order interface{}) *IndicesPutTemplateService

Order is the order for this template when merging multiple matching ones (higher numbers are merged later, overriding the lower numbers).

func (*IndicesPutTemplateService) Pretty 

func (s *IndicesPutTemplateService) Pretty(pretty bool) *IndicesPutTemplateService

Pretty indicates that the JSON response be indented and human readable.

func (*IndicesPutTemplateService) Timeout 

func (s *IndicesPutTemplateService) Timeout(timeout string) *IndicesPutTemplateService

Timeout is an explicit operation timeout.

func (*IndicesPutTemplateService) Validate 

func (s *IndicesPutTemplateService) Validate() error

Validate checks if the operation is valid.

type IndicesPutWarmerService 

type IndicesPutWarmerService struct {
	// contains filtered or unexported fields
}

IndicesPutWarmerService allows to register a warmer. See https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-warmers.html.

func NewIndicesPutWarmerService 

func NewIndicesPutWarmerService(client *Client) *IndicesPutWarmerService

NewIndicesPutWarmerService creates a new IndicesPutWarmerService.

func (*IndicesPutWarmerService) AllowNoIndices 

func (s *IndicesPutWarmerService) AllowNoIndices(allowNoIndices bool) *IndicesPutWarmerService

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 (*IndicesPutWarmerService) BodyJson 

func (s *IndicesPutWarmerService) BodyJson(mapping map[string]interface{}) *IndicesPutWarmerService

BodyJson contains the mapping definition.

func (*IndicesPutWarmerService) BodyString 

func (s *IndicesPutWarmerService) BodyString(mapping string) *IndicesPutWarmerService

BodyString is the mapping definition serialized as a string.

func (*IndicesPutWarmerService) Do 

func (s *IndicesPutWarmerService) Do() (*PutWarmerResponse, error)

Do executes the operation.

func (*IndicesPutWarmerService) ExpandWildcards 

func (s *IndicesPutWarmerService) ExpandWildcards(expandWildcards string) *IndicesPutWarmerService

ExpandWildcards indicates whether to expand wildcard expression to concrete indices that are open, closed or both.

func (*IndicesPutWarmerService) IgnoreUnavailable 

func (s *IndicesPutWarmerService) IgnoreUnavailable(ignoreUnavailable bool) *IndicesPutWarmerService

IgnoreUnavailable indicates whether specified concrete indices should be ignored when unavailable (missing or closed).

func (*IndicesPutWarmerService) Index 

func (s *IndicesPutWarmerService) Index(indices ...string) *IndicesPutWarmerService

Index is a list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices.

func (*IndicesPutWarmerService) MasterTimeout 

func (s *IndicesPutWarmerService) MasterTimeout(masterTimeout string) *IndicesPutWarmerService

MasterTimeout specifies the timeout for connection to master.

func (*IndicesPutWarmerService) Name 

func (s *IndicesPutWarmerService) Name(name string) *IndicesPutWarmerService

Name specifies the name of the warmer (supports wildcards); leave empty to get all warmers

func (*IndicesPutWarmerService) Pretty 

func (s *IndicesPutWarmerService) Pretty(pretty bool) *IndicesPutWarmerService

Pretty indicates that the JSON response be indented and human readable.

func (*IndicesPutWarmerService) RequestCache 

func (s *IndicesPutWarmerService) RequestCache(requestCache bool) *IndicesPutWarmerService

RequestCache specifies whether the request to be warmed should use the request cache, defaults to index level setting

func (*IndicesPutWarmerService) Type 

func (s *IndicesPutWarmerService) Type(typ ...string) *IndicesPutWarmerService

Type is a list of type names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all types.

func (*IndicesPutWarmerService) Validate 

func (s *IndicesPutWarmerService) Validate() error

Validate checks if the operation is valid.

type IndicesStatsResponse 

type IndicesStatsResponse struct {
	// Shards provides information returned from shards.
	Shards shardsInfo `json:"_shards"`

	// All provides summary stats about all indices.
	All *IndexStats `json:"_all,omitempty"`

	// Indices provides a map into the stats of an index. The key of the
	// map is the index name.
	Indices map[string]*IndexStats `json:"indices,omitempty"`
}

IndicesStatsResponse is the response of IndicesStatsService.Do.

type IndicesStatsService 

type IndicesStatsService struct {
	// contains filtered or unexported fields
}

IndicesStatsService provides stats on various metrics of one or more indices. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-stats.html.

func NewIndicesStatsService 

func NewIndicesStatsService(client *Client) *IndicesStatsService

NewIndicesStatsService creates a new IndicesStatsService.

func (*IndicesStatsService) CompletionFields 

func (s *IndicesStatsService) CompletionFields(completionFields ...string) *IndicesStatsService

CompletionFields is a list of fields for `fielddata` and `suggest` index metric (supports wildcards).

func (*IndicesStatsService) Do 

func (s *IndicesStatsService) Do() (*IndicesStatsResponse, error)

Do executes the operation.

func (*IndicesStatsService) FielddataFields 

func (s *IndicesStatsService) FielddataFields(fielddataFields ...string) *IndicesStatsService

FielddataFields is a list of fields for `fielddata` index metric (supports wildcards).

func (*IndicesStatsService) Fields 

func (s *IndicesStatsService) Fields(fields ...string) *IndicesStatsService

Fields is a list of fields for `fielddata` and `completion` index metric (supports wildcards).

func (*IndicesStatsService) Groups 

func (s *IndicesStatsService) Groups(groups ...string) *IndicesStatsService

Groups is a list of search groups for `search` index metric.

func (*IndicesStatsService) Human 

func (s *IndicesStatsService) Human(human bool) *IndicesStatsService

Human indicates whether to return time and byte values in human-readable format..

func (*IndicesStatsService) Index 

func (s *IndicesStatsService) Index(index ...string) *IndicesStatsService

Index is the list of index names; use `_all` or empty string to perform the operation on all indices.

func (*IndicesStatsService) Level 

func (s *IndicesStatsService) Level(level string) *IndicesStatsService

Level returns stats aggregated at cluster, index or shard level.

func (*IndicesStatsService) Metric 

func (s *IndicesStatsService) Metric(metric ...string) *IndicesStatsService

Metric limits the information returned the specific metrics. Options are: docs, store, indexing, get, search, completion, fielddata, flush, merge, query_cache, refresh, suggest, and warmer.

func (*IndicesStatsService) Pretty 

func (s *IndicesStatsService) Pretty(pretty bool) *IndicesStatsService

Pretty indicates that the JSON response be indented and human readable.

func (*IndicesStatsService) Types 

func (s *IndicesStatsService) Types(types ...string) *IndicesStatsService

Types is a list of document types for the `indexing` index metric.

func (*IndicesStatsService) Validate 

func (s *IndicesStatsService) Validate() error

Validate checks if the operation is valid.

type InnerHit 

type InnerHit struct {
	// contains filtered or unexported fields
}

InnerHit implements a simple join for parent/child, nested, and even top-level documents in Elasticsearch. It is an experimental feature for Elasticsearch versions 1.5 (or greater). See http://www.elastic.co/guide/en/elasticsearch/reference/1.5/search-request-inner-hits.html for documentation.

See the tests for SearchSource, HasChildFilter, HasChildQuery, HasParentFilter, HasParentQuery, NestedFilter, and NestedQuery for usage examples.

func NewInnerHit 

func NewInnerHit() *InnerHit

NewInnerHit creates a new InnerHit.

func (*InnerHit) Explain 

func (hit *InnerHit) Explain(explain bool) *InnerHit

func (*InnerHit) FetchSource 

func (hit *InnerHit) FetchSource(fetchSource bool) *InnerHit

func (*InnerHit) FetchSourceContext 

func (hit *InnerHit) FetchSourceContext(fetchSourceContext *FetchSourceContext) *InnerHit

func (*InnerHit) Field 

func (hit *InnerHit) Field(fieldName string) *InnerHit

func (*InnerHit) FieldDataField 

func (hit *InnerHit) FieldDataField(fieldDataField string) *InnerHit

func (*InnerHit) FieldDataFields 

func (hit *InnerHit) FieldDataFields(fieldDataFields ...string) *InnerHit

func (*InnerHit) Fields 

func (hit *InnerHit) Fields(fieldNames ...string) *InnerHit

func (*InnerHit) From 

func (hit *InnerHit) From(from int) *InnerHit

func (*InnerHit) Highlight 

func (hit *InnerHit) Highlight(highlight *Highlight) *InnerHit

func (*InnerHit) Highlighter 

func (hit *InnerHit) Highlighter() *Highlight

func (*InnerHit) Name 

func (hit *InnerHit) Name(name string) *InnerHit

func (*InnerHit) NoFields 

func (hit *InnerHit) NoFields() *InnerHit

func (*InnerHit) Path 

func (hit *InnerHit) Path(path string) *InnerHit

func (*InnerHit) Query 

func (hit *InnerHit) Query(query Query) *InnerHit

func (*InnerHit) ScriptField 

func (hit *InnerHit) ScriptField(scriptField *ScriptField) *InnerHit

func (*InnerHit) ScriptFields 

func (hit *InnerHit) ScriptFields(scriptFields ...*ScriptField) *InnerHit

func (*InnerHit) Size 

func (hit *InnerHit) Size(size int) *InnerHit

func (*InnerHit) Sort 

func (hit *InnerHit) Sort(field string, ascending bool) *InnerHit

func (*InnerHit) SortBy 

func (hit *InnerHit) SortBy(sorter ...Sorter) *InnerHit

func (*InnerHit) SortWithInfo 

func (hit *InnerHit) SortWithInfo(info SortInfo) *InnerHit

func (*InnerHit) Source 

func (hit *InnerHit) Source() interface{}

func (*InnerHit) TrackScores 

func (hit *InnerHit) TrackScores(trackScores bool) *InnerHit

func (*InnerHit) Type 

func (hit *InnerHit) Type(typ string) *InnerHit

func (*InnerHit) Version 

func (hit *InnerHit) Version(version bool) *InnerHit

type LaplaceSmoothingModel 

type LaplaceSmoothingModel struct {
	// contains filtered or unexported fields
}

LaplaceSmoothingModel implements a laplace smoothing model. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-suggesters-phrase.html#_smoothing_models for details about smoothing models.

func NewLaplaceSmoothingModel 

func NewLaplaceSmoothingModel(alpha float64) *LaplaceSmoothingModel

func (*LaplaceSmoothingModel) Source 

func (sm *LaplaceSmoothingModel) Source() interface{}

func (*LaplaceSmoothingModel) Type 

func (sm *LaplaceSmoothingModel) Type() string

type LimitFilter 

type LimitFilter struct {
	Filter
	// contains filtered or unexported fields
}

A limit filter limits the number of documents (per shard) to execute on. For details, see: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-limit-filter.html

func NewLimitFilter 

func NewLimitFilter(limit int) LimitFilter

func (LimitFilter) Source 

func (f LimitFilter) Source() interface{}

type LinearDecayFunction 

type LinearDecayFunction struct {
	// contains filtered or unexported fields
}

LinearDecayFunction builds a linear decay score function. See https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-function-score-query.html for details.

func NewLinearDecayFunction 

func NewLinearDecayFunction() LinearDecayFunction

NewLinearDecayFunction initializes and returns a new LinearDecayFunction.

func (LinearDecayFunction) Decay 

func (fn LinearDecayFunction) Decay(decay float64) LinearDecayFunction

Decay defines how documents are scored at the distance given a Scale. If no decay is defined, documents at the distance Scale will be scored 0.5.

func (LinearDecayFunction) FieldName 

func (fn LinearDecayFunction) FieldName(fieldName string) LinearDecayFunction

FieldName specifies the name of the field to which this decay function is applied to.

func (LinearDecayFunction) GetMultiValueMode 

func (fn LinearDecayFunction) GetMultiValueMode() string

GetMultiValueMode returns how the decay function should be calculated on a field that has multiple values. Valid modes are: min, max, avg, and sum.

func (LinearDecayFunction) GetWeight 

func (fn LinearDecayFunction) GetWeight() *float64

GetWeight returns the adjusted score. It is part of the ScoreFunction interface. Returns nil if weight is not specified.

func (LinearDecayFunction) MultiValueMode 

func (fn LinearDecayFunction) MultiValueMode(mode string) LinearDecayFunction

MultiValueMode specifies how the decay function should be calculated on a field that has multiple values. Valid modes are: min, max, avg, and sum.

func (LinearDecayFunction) Name 

func (fn LinearDecayFunction) Name() string

Name represents the JSON field name under which the output of Source needs to be serialized by FunctionScoreQuery (see FunctionScoreQuery.Source).

func (LinearDecayFunction) Offset 

func (fn LinearDecayFunction) Offset(offset interface{}) LinearDecayFunction

Offset, if defined, computes the decay function only for a distance greater than the defined offset.

func (LinearDecayFunction) Origin 

func (fn LinearDecayFunction) Origin(origin interface{}) LinearDecayFunction

Origin defines the "central point" by which the decay function calculates "distance".

func (LinearDecayFunction) Scale 

func (fn LinearDecayFunction) Scale(scale interface{}) LinearDecayFunction

Scale defines the scale to be used with Decay.

func (LinearDecayFunction) Source 

func (fn LinearDecayFunction) Source() interface{}

Source returns the serializable JSON data of this score function.

func (LinearDecayFunction) Weight 

func (fn LinearDecayFunction) Weight(weight float64) LinearDecayFunction

Weight adjusts the score of the score function. See https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-function-score-query.html#_using_function_score for details.

type LinearInterpolationSmoothingModel 

type LinearInterpolationSmoothingModel struct {
	// contains filtered or unexported fields
}

LinearInterpolationSmoothingModel implements a linear interpolation smoothing model. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-suggesters-phrase.html#_smoothing_models for details about smoothing models.

func NewLinearInterpolationSmoothingModel 

func NewLinearInterpolationSmoothingModel(trigramLamda, bigramLambda, unigramLambda float64) *LinearInterpolationSmoothingModel

func (*LinearInterpolationSmoothingModel) Source 

func (sm *LinearInterpolationSmoothingModel) Source() interface{}

func (*LinearInterpolationSmoothingModel) Type 

func (sm *LinearInterpolationSmoothingModel) Type() string

type Logger 

type Logger interface {
	Printf(format string, v ...interface{})
}

Logger specifies the interface for all log operations.

type MatchAllFilter 

type MatchAllFilter struct {
	Filter
}

A filter that matches on all documents. For details, see: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-match-all-filter.html

func NewMatchAllFilter 

func NewMatchAllFilter() MatchAllFilter

func (MatchAllFilter) Source 

func (f MatchAllFilter) Source() interface{}

type MatchAllQuery 

type MatchAllQuery struct {
	Query
	// contains filtered or unexported fields
}

A query that matches all documents. Maps to Lucene MatchAllDocsQuery. For more details, see http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-match-all-query.html

func NewMatchAllQuery 

func NewMatchAllQuery() MatchAllQuery

NewMatchAllQuery creates a new match all query.

func (MatchAllQuery) Boost 

func (q MatchAllQuery) Boost(boost float32) MatchAllQuery

func (MatchAllQuery) NormsField 

func (q MatchAllQuery) NormsField(normsField string) MatchAllQuery

func (MatchAllQuery) Source 

func (q MatchAllQuery) Source() interface{}

Creates the query source for the match all query.

type MatchQuery 

type MatchQuery struct {
	Query
	// contains filtered or unexported fields
}

MatchQuery is a family of queries that accept text/numerics/dates, analyzes it, and constructs a query out of it. For more details, see http://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-match-query.html.

To create a new MatchQuery, use NewMatchQuery. To create specific types of queries, e.g. a match_phrase query, use NewMatchQuery(...).Type("phrase"), or use one of the shortcuts like NewMatchPhraseQuery(...).

func NewMatchPhrasePrefixQuery 

func NewMatchPhrasePrefixQuery(name string, value interface{}) MatchQuery

NewMatchPhrasePrefixQuery creates a new MatchQuery with type phrase_prefix.

func NewMatchPhraseQuery 

func NewMatchPhraseQuery(name string, value interface{}) MatchQuery

NewMatchPhraseQuery creates a new MatchQuery with type phrase.

func NewMatchQuery 

func NewMatchQuery(name string, value interface{}) MatchQuery

NewMatchQuery creates a new MatchQuery.

func (MatchQuery) Analyzer 

func (q MatchQuery) Analyzer(analyzer string) MatchQuery

func (MatchQuery) Boost 

func (q MatchQuery) Boost(boost float32) MatchQuery

func (MatchQuery) CutoffFrequency 

func (q MatchQuery) CutoffFrequency(cutoff float32) MatchQuery

func (MatchQuery) Fuzziness 

func (q MatchQuery) Fuzziness(fuzziness string) MatchQuery

func (MatchQuery) FuzzyRewrite 

func (q MatchQuery) FuzzyRewrite(fuzzyRewrite string) MatchQuery

func (MatchQuery) FuzzyTranspositions 

func (q MatchQuery) FuzzyTranspositions(fuzzyTranspositions bool) MatchQuery

func (MatchQuery) Lenient 

func (q MatchQuery) Lenient(lenient bool) MatchQuery

func (MatchQuery) MaxExpansions 

func (q MatchQuery) MaxExpansions(maxExpansions int) MatchQuery

func (MatchQuery) MinimumShouldMatch 

func (q MatchQuery) MinimumShouldMatch(minimumShouldMatch string) MatchQuery

func (MatchQuery) Operator 

func (q MatchQuery) Operator(operator string) MatchQuery

func (MatchQuery) PrefixLength 

func (q MatchQuery) PrefixLength(prefixLength int) MatchQuery

func (MatchQuery) QueryName 

func (q MatchQuery) QueryName(queryName string) MatchQuery

func (MatchQuery) Rewrite 

func (q MatchQuery) Rewrite(rewrite string) MatchQuery

func (MatchQuery) Slop 

func (q MatchQuery) Slop(slop int) MatchQuery

func (MatchQuery) Source 

func (q MatchQuery) Source() interface{}

func (MatchQuery) Type 

func (q MatchQuery) Type(matchQueryType string) MatchQuery

Type can be "boolean", "phrase", or "phrase_prefix".

func (MatchQuery) ZeroTermsQuery 

func (q MatchQuery) ZeroTermsQuery(zeroTermsQuery string) MatchQuery

ZeroTermsQuery can be "all" or "none".

type MaxAggregation 

type MaxAggregation struct {
	// contains filtered or unexported fields
}

MaxAggregation is a single-value metrics aggregation that keeps track and returns the maximum value among the numeric values extracted from the aggregated documents. These values can be extracted either from specific numeric fields in the documents, or be generated by a provided script. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-metrics-max-aggregation.html

func NewMaxAggregation 

func NewMaxAggregation() MaxAggregation

func (MaxAggregation) Field 

func (a MaxAggregation) Field(field string) MaxAggregation

func (MaxAggregation) Format 

func (a MaxAggregation) Format(format string) MaxAggregation

func (MaxAggregation) Lang 

func (a MaxAggregation) Lang(lang string) MaxAggregation

func (MaxAggregation) Param 

func (a MaxAggregation) Param(name string, value interface{}) MaxAggregation

func (MaxAggregation) Script 

func (a MaxAggregation) Script(script string) MaxAggregation

func (MaxAggregation) ScriptFile 

func (a MaxAggregation) ScriptFile(scriptFile string) MaxAggregation

func (MaxAggregation) Source 

func (a MaxAggregation) Source() interface{}

func (MaxAggregation) SubAggregation 

func (a MaxAggregation) SubAggregation(name string, subAggregation Aggregation) MaxAggregation

type MinAggregation 

type MinAggregation struct {
	// contains filtered or unexported fields
}

MinAggregation is a single-value metrics aggregation that keeps track and returns the minimum value among numeric values extracted from the aggregated documents. These values can be extracted either from specific numeric fields in the documents, or be generated by a provided script. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-metrics-min-aggregation.html

func NewMinAggregation 

func NewMinAggregation() MinAggregation

func (MinAggregation) Field 

func (a MinAggregation) Field(field string) MinAggregation

func (MinAggregation) Format 

func (a MinAggregation) Format(format string) MinAggregation

func (MinAggregation) Lang 

func (a MinAggregation) Lang(lang string) MinAggregation

func (MinAggregation) Param 

func (a MinAggregation) Param(name string, value interface{}) MinAggregation

func (MinAggregation) Script 

func (a MinAggregation) Script(script string) MinAggregation

func (MinAggregation) ScriptFile 

func (a MinAggregation) ScriptFile(scriptFile string) MinAggregation

func (MinAggregation) Source 

func (a MinAggregation) Source() interface{}

func (MinAggregation) SubAggregation 

func (a MinAggregation) SubAggregation(name string, subAggregation Aggregation) MinAggregation

type MissingAggregation 

type MissingAggregation struct {
	// contains filtered or unexported fields
}

MissingAggregation is a field data based single bucket aggregation, that creates a bucket of all documents in the current document set context that are missing a field value (effectively, missing a field or having the configured NULL value set). This aggregator will often be used in conjunction with other field data bucket aggregators (such as ranges) to return information for all the documents that could not be placed in any of the other buckets due to missing field data values. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-missing-aggregation.html

func NewMissingAggregation 

func NewMissingAggregation() MissingAggregation

func (MissingAggregation) Field 

func (a MissingAggregation) Field(field string) MissingAggregation

func (MissingAggregation) Source 

func (a MissingAggregation) Source() interface{}

func (MissingAggregation) SubAggregation 

func (a MissingAggregation) SubAggregation(name string, subAggregation Aggregation) MissingAggregation

type MissingFilter 

type MissingFilter struct {
	Filter
	// contains filtered or unexported fields
}

Filters documents where a specific field has no value in them. For details, see: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-missing-filter.html

func NewMissingFilter 

func NewMissingFilter(name string) MissingFilter

func (MissingFilter) Existence 

func (f MissingFilter) Existence(existence bool) MissingFilter

func (MissingFilter) FilterName 

func (f MissingFilter) FilterName(filterName string) MissingFilter

func (MissingFilter) NullValue 

func (f MissingFilter) NullValue(nullValue bool) MissingFilter

func (MissingFilter) Source 

func (f MissingFilter) Source() interface{}

type MoreLikeThisFieldQuery 

type MoreLikeThisFieldQuery struct {
	Query
	// contains filtered or unexported fields
}

The more_like_this_field query is the same as the more_like_this query, except it runs against a single field. It provides nicer query DSL over the generic more_like_this query, and support typed fields query (automatically wraps typed fields with type filter to match only on the specific type).

For more details, see: http://www.elasticsearch.org/guide/reference/query-dsl/mlt-field-query/

func NewMoreLikeThisFieldQuery 

func NewMoreLikeThisFieldQuery(name, likeText string) MoreLikeThisFieldQuery

Creates a new mlt_field query.

func (MoreLikeThisFieldQuery) Analyzer 

func (q MoreLikeThisFieldQuery) Analyzer(analyzer string) MoreLikeThisFieldQuery

func (MoreLikeThisFieldQuery) Boost 

func (q MoreLikeThisFieldQuery) Boost(boost float32) MoreLikeThisFieldQuery

func (MoreLikeThisFieldQuery) BoostTerms 

func (q MoreLikeThisFieldQuery) BoostTerms(boostTerms float32) MoreLikeThisFieldQuery

func (MoreLikeThisFieldQuery) FailOnUnsupportedField 

func (q MoreLikeThisFieldQuery) FailOnUnsupportedField(fail bool) MoreLikeThisFieldQuery

func (MoreLikeThisFieldQuery) LikeText 

func (q MoreLikeThisFieldQuery) LikeText(likeText string) MoreLikeThisFieldQuery

func (MoreLikeThisFieldQuery) MaxDocFreq 

func (q MoreLikeThisFieldQuery) MaxDocFreq(maxDocFreq int) MoreLikeThisFieldQuery

func (MoreLikeThisFieldQuery) MaxQueryTerms 

func (q MoreLikeThisFieldQuery) MaxQueryTerms(maxQueryTerms int) MoreLikeThisFieldQuery

func (MoreLikeThisFieldQuery) MaxWordLen 

func (q MoreLikeThisFieldQuery) MaxWordLen(maxWordLen int) MoreLikeThisFieldQuery

func (MoreLikeThisFieldQuery) MinDocFreq 

func (q MoreLikeThisFieldQuery) MinDocFreq(minDocFreq int) MoreLikeThisFieldQuery

func (MoreLikeThisFieldQuery) MinTermFreq 

func (q MoreLikeThisFieldQuery) MinTermFreq(minTermFreq int) MoreLikeThisFieldQuery

func (MoreLikeThisFieldQuery) MinWordLen 

func (q MoreLikeThisFieldQuery) MinWordLen(minWordLen int) MoreLikeThisFieldQuery

func (MoreLikeThisFieldQuery) Name 

func (q MoreLikeThisFieldQuery) Name(name string) MoreLikeThisFieldQuery

func (MoreLikeThisFieldQuery) PercentTermsToMatch 

func (q MoreLikeThisFieldQuery) PercentTermsToMatch(percentTermsToMatch float32) MoreLikeThisFieldQuery

func (MoreLikeThisFieldQuery) Source 

func (q MoreLikeThisFieldQuery) Source() interface{}

Creates the query source for the mlt query.

func (MoreLikeThisFieldQuery) StopWord 

func (q MoreLikeThisFieldQuery) StopWord(stopWord string) MoreLikeThisFieldQuery

func (MoreLikeThisFieldQuery) StopWords 

func (q MoreLikeThisFieldQuery) StopWords(stopWords ...string) MoreLikeThisFieldQuery

type MoreLikeThisQuery 

type MoreLikeThisQuery struct {
	// contains filtered or unexported fields
}

More like this query find documents that are “like” provided text by running it against one or more fields. For more details, see http://www.elasticsearch.org/guide/reference/query-dsl/mlt-query/

func NewMoreLikeThisQuery 

func NewMoreLikeThisQuery(likeText string) MoreLikeThisQuery

NewMoreLikeThisQuery creates a new more-like-this query.

func (MoreLikeThisQuery) Analyzer 

func (q MoreLikeThisQuery) Analyzer(analyzer string) MoreLikeThisQuery

Analyzer specifies the analyzer that will be use to analyze the text. Defaults to the analyzer associated with the field.

func (MoreLikeThisQuery) Boost 

func (q MoreLikeThisQuery) Boost(boost float64) MoreLikeThisQuery

Boost sets the boost for this query.

func (MoreLikeThisQuery) BoostTerms 

func (q MoreLikeThisQuery) BoostTerms(boostTerms float64) MoreLikeThisQuery

BoostTerms sets the boost factor to use when boosting terms. It defaults to 1.

func (MoreLikeThisQuery) Docs 

func (q MoreLikeThisQuery) Docs(docs ...*MoreLikeThisQueryItem) MoreLikeThisQuery

Docs sets the documents to use in order to find documents that are "like" this.

func (MoreLikeThisQuery) FailOnUnsupportedField 

func (q MoreLikeThisQuery) FailOnUnsupportedField(fail bool) MoreLikeThisQuery

FailOnUnsupportedField indicates whether to fail or return no result when this query is run against a field which is not supported such as a binary/numeric field.

func (MoreLikeThisQuery) Field 

func (q MoreLikeThisQuery) Field(fields ...string) MoreLikeThisQuery

Field adds one or more field names to the query.

func (MoreLikeThisQuery) Fields 

func (q MoreLikeThisQuery) Fields(fields ...string) MoreLikeThisQuery

Fields adds one or more field names to the query. Deprecated: Use Field for compatibility with elastic.v3.

func (MoreLikeThisQuery) Ids 

func (q MoreLikeThisQuery) Ids(ids ...string) MoreLikeThisQuery

Ids sets the document ids to use in order to find documents that are "like" this.

func (MoreLikeThisQuery) Include 

func (q MoreLikeThisQuery) Include(include bool) MoreLikeThisQuery

Include specifies whether the input documents should also be included in the results returned. Defaults to false.

func (MoreLikeThisQuery) LikeText 

func (q MoreLikeThisQuery) LikeText(likeText string) MoreLikeThisQuery

LikeText sets the text to use in order to find documents that are "like" this.

func (MoreLikeThisQuery) MaxDocFreq 

func (q MoreLikeThisQuery) MaxDocFreq(maxDocFreq int) MoreLikeThisQuery

MaxDocFreq sets the maximum frequency for which words may still appear. Words that appear in more than this many docs will be ignored. It defaults to unbounded.

func (MoreLikeThisQuery) MaxQueryTerms 

func (q MoreLikeThisQuery) MaxQueryTerms(maxQueryTerms int) MoreLikeThisQuery

MaxQueryTerms sets the maximum number of query terms that will be included in any generated query. It defaults to 25.

func (MoreLikeThisQuery) MaxWordLen 

func (q MoreLikeThisQuery) MaxWordLen(maxWordLen int) MoreLikeThisQuery

MaxWordLen sets the maximum word length above which words will be ignored. Defaults to unbounded (0).

func (MoreLikeThisQuery) MinDocFreq 

func (q MoreLikeThisQuery) MinDocFreq(minDocFreq int) MoreLikeThisQuery

MinDocFreq sets the frequency at which words will be ignored which do not occur in at least this many docs. The default is 5.

func (MoreLikeThisQuery) MinTermFreq 

func (q MoreLikeThisQuery) MinTermFreq(minTermFreq int) MoreLikeThisQuery

MinTermFreq is the frequency below which terms will be ignored in the source doc. The default frequency is 2.

func (MoreLikeThisQuery) MinWordLen 

func (q MoreLikeThisQuery) MinWordLen(minWordLen int) MoreLikeThisQuery

MinWordLength sets the minimum word length below which words will be ignored. It defaults to 0.

func (MoreLikeThisQuery) MinimumShouldMatch 

func (q MoreLikeThisQuery) MinimumShouldMatch(minimumShouldMatch string) MoreLikeThisQuery

MinimumShouldMatch sets the number of terms that must match the generated query expressed in the common syntax for minimum should match. The default value is "30%".

This used to be "PercentTermsToMatch".

func (MoreLikeThisQuery) PercentTermsToMatch 

func (q MoreLikeThisQuery) PercentTermsToMatch(percentTermsToMatch float64) MoreLikeThisQuery

PercentTermsToMatch will be changed to MinimumShouldMatch.

func (MoreLikeThisQuery) QueryName 

func (q MoreLikeThisQuery) QueryName(queryName string) MoreLikeThisQuery

QueryName sets the query name for the filter that can be used when searching for matched_filters per hit.

func (MoreLikeThisQuery) Source 

func (q MoreLikeThisQuery) Source() interface{}

Creates the query source for the mlt query.

func (MoreLikeThisQuery) StopWord 

func (q MoreLikeThisQuery) StopWord(stopWords ...string) MoreLikeThisQuery

StopWord sets the stopwords. Any word in this set is considered "uninteresting" and ignored. Even if your Analyzer allows stopwords, you might want to tell the MoreLikeThis code to ignore them, as for the purposes of document similarity it seems reasonable to assume that "a stop word is never interesting".

func (MoreLikeThisQuery) StopWords 

func (q MoreLikeThisQuery) StopWords(stopWords ...string) MoreLikeThisQuery

StopWords is an alias for StopWord. Deprecated: Use StopWord for compatibility with elastic.v3.

type MoreLikeThisQueryItem 

type MoreLikeThisQueryItem struct {
	// contains filtered or unexported fields
}

MoreLikeThisQueryItem represents a single item of a MoreLikeThisQuery to be "liked" or "unliked".

func NewMoreLikeThisQueryItem 

func NewMoreLikeThisQueryItem() *MoreLikeThisQueryItem

NewMoreLikeThisQueryItem creates and initializes a MoreLikeThisQueryItem.

func (*MoreLikeThisQueryItem) Doc 

func (item *MoreLikeThisQueryItem) Doc(doc interface{}) *MoreLikeThisQueryItem

Doc represents a raw document template for the item.

func (*MoreLikeThisQueryItem) FetchSourceContext 

func (item *MoreLikeThisQueryItem) FetchSourceContext(fsc *FetchSourceContext) *MoreLikeThisQueryItem

FetchSourceContext represents the fetch source of the item which controls if and how _source should be returned.

func (*MoreLikeThisQueryItem) Fields 

func (item *MoreLikeThisQueryItem) Fields(fields ...string) *MoreLikeThisQueryItem

Fields represents the list of fields of the item.

func (*MoreLikeThisQueryItem) Id 

func (item *MoreLikeThisQueryItem) Id(id string) *MoreLikeThisQueryItem

Id represents the document id of the item.

func (*MoreLikeThisQueryItem) Index 

func (item *MoreLikeThisQueryItem) Index(index string) *MoreLikeThisQueryItem

Index represents the index of the item.

func (*MoreLikeThisQueryItem) LikeText 

func (item *MoreLikeThisQueryItem) LikeText(likeText string) *MoreLikeThisQueryItem

LikeText represents a text to be "liked".

func (*MoreLikeThisQueryItem) Routing 

func (item *MoreLikeThisQueryItem) Routing(routing string) *MoreLikeThisQueryItem

Routing sets the routing associated with the item.

func (*MoreLikeThisQueryItem) Source 

func (item *MoreLikeThisQueryItem) Source() interface{}

Source returns the JSON-serializable fragment of the entity.

func (*MoreLikeThisQueryItem) Type 

func (item *MoreLikeThisQueryItem) Type(typ string) *MoreLikeThisQueryItem

Type represents the document type of the item.

func (*MoreLikeThisQueryItem) Version 

func (item *MoreLikeThisQueryItem) Version(version int64) *MoreLikeThisQueryItem

Version specifies the version of the item.

func (*MoreLikeThisQueryItem) VersionType 

func (item *MoreLikeThisQueryItem) VersionType(versionType string) *MoreLikeThisQueryItem

VersionType represents the version type of the item.

type MultiGetItem 

type MultiGetItem struct {
	// contains filtered or unexported fields
}

MultiGetItem is a single document to retrieve via the MultiGetService.

func NewMultiGetItem 

func NewMultiGetItem() *MultiGetItem

func (*MultiGetItem) FetchSource 

func (item *MultiGetItem) FetchSource(fetchSourceContext *FetchSourceContext) *MultiGetItem

func (*MultiGetItem) Fields 

func (item *MultiGetItem) Fields(fields ...string) *MultiGetItem

func (*MultiGetItem) Id 

func (item *MultiGetItem) Id(id string) *MultiGetItem

func (*MultiGetItem) Index 

func (item *MultiGetItem) Index(index string) *MultiGetItem

func (*MultiGetItem) Routing 

func (item *MultiGetItem) Routing(routing string) *MultiGetItem

func (*MultiGetItem) Source 

func (item *MultiGetItem) Source() interface{}

Source returns the serialized JSON to be sent to Elasticsearch as part of a MultiGet search.

func (*MultiGetItem) Type 

func (item *MultiGetItem) Type(typ string) *MultiGetItem

func (*MultiGetItem) Version 

func (item *MultiGetItem) Version(version int64) *MultiGetItem

Version can be MatchAny (-3), MatchAnyPre120 (0), NotFound (-1), or NotSet (-2). These are specified in org.elasticsearch.common.lucene.uid.Versions. The default in Elasticsearch is MatchAny (-3).

func (*MultiGetItem) VersionType 

func (item *MultiGetItem) VersionType(versionType string) *MultiGetItem

VersionType can be "internal", "external", "external_gt", "external_gte", or "force". See org.elasticsearch.index.VersionType in Elasticsearch source. It is "internal" by default.

type MultiGetResult 

type MultiGetResult struct {
	Docs []*GetResult `json:"docs,omitempty"`
}

type MultiGetService 

type MultiGetService struct {
	// contains filtered or unexported fields
}

func NewMultiGetService 

func NewMultiGetService(client *Client) *MultiGetService

func (*MultiGetService) Add 

func (b *MultiGetService) Add(items ...*MultiGetItem) *MultiGetService

func (*MultiGetService) Do 

func (b *MultiGetService) Do() (*MultiGetResult, error)

func (*MultiGetService) Preference 

func (b *MultiGetService) Preference(preference string) *MultiGetService

func (*MultiGetService) Realtime 

func (b *MultiGetService) Realtime(realtime bool) *MultiGetService

func (*MultiGetService) Refresh 

func (b *MultiGetService) Refresh(refresh bool) *MultiGetService

func (*MultiGetService) Source 

func (b *MultiGetService) Source() interface{}

type MultiMatchQuery 

type MultiMatchQuery struct {
	Query
	// contains filtered or unexported fields
}

The multi_match query builds further on top of the match query by allowing multiple fields to be specified. For more details, see: http://www.elasticsearch.org/guide/reference/query-dsl/multi-match-query.html

func NewMultiMatchQuery 

func NewMultiMatchQuery(text interface{}, fields ...string) MultiMatchQuery

func (MultiMatchQuery) Analyzer 

func (q MultiMatchQuery) Analyzer(analyzer string) MultiMatchQuery

func (MultiMatchQuery) Boost 

func (q MultiMatchQuery) Boost(boost float32) MultiMatchQuery

func (MultiMatchQuery) CutoffFrequency 

func (q MultiMatchQuery) CutoffFrequency(cutoff float32) MultiMatchQuery

func (MultiMatchQuery) Field 

func (q MultiMatchQuery) Field(field string) MultiMatchQuery

func (MultiMatchQuery) FieldWithBoost 

func (q MultiMatchQuery) FieldWithBoost(field string, boost float32) MultiMatchQuery

func (MultiMatchQuery) Fuzziness 

func (q MultiMatchQuery) Fuzziness(fuzziness string) MultiMatchQuery

func (MultiMatchQuery) FuzzyRewrite 

func (q MultiMatchQuery) FuzzyRewrite(fuzzyRewrite string) MultiMatchQuery

func (MultiMatchQuery) Lenient 

func (q MultiMatchQuery) Lenient(lenient bool) MultiMatchQuery

func (MultiMatchQuery) MaxExpansions 

func (q MultiMatchQuery) MaxExpansions(maxExpansions int) MultiMatchQuery

func (MultiMatchQuery) MinimumShouldMatch 

func (q MultiMatchQuery) MinimumShouldMatch(minimumShouldMatch string) MultiMatchQuery

func (MultiMatchQuery) Operator 

func (q MultiMatchQuery) Operator(operator string) MultiMatchQuery

func (MultiMatchQuery) PrefixLength 

func (q MultiMatchQuery) PrefixLength(prefixLength int) MultiMatchQuery

func (MultiMatchQuery) QueryName 

func (q MultiMatchQuery) QueryName(queryName string) MultiMatchQuery

func (MultiMatchQuery) Rewrite 

func (q MultiMatchQuery) Rewrite(rewrite string) MultiMatchQuery

func (MultiMatchQuery) Slop 

func (q MultiMatchQuery) Slop(slop int) MultiMatchQuery

func (MultiMatchQuery) Source 

func (q MultiMatchQuery) Source() interface{}

func (MultiMatchQuery) TieBreaker 

func (q MultiMatchQuery) TieBreaker(tieBreaker float32) MultiMatchQuery

func (MultiMatchQuery) Type 

func (q MultiMatchQuery) Type(matchQueryType string) MultiMatchQuery

Type can be: "best_fields", "boolean", "most_fields", "cross_fields", "phrase", or "phrase_prefix".

func (MultiMatchQuery) UseDisMax 

func (q MultiMatchQuery) UseDisMax(useDisMax bool) MultiMatchQuery

Deprecated.

func (MultiMatchQuery) ZeroTermsQuery 

func (q MultiMatchQuery) ZeroTermsQuery(zeroTermsQuery string) MultiMatchQuery

ZeroTermsQuery can be "all" or "none".

type MultiSearchResult 

type MultiSearchResult struct {
	Responses []*SearchResult `json:"responses,omitempty"`
}

type MultiSearchService 

type MultiSearchService struct {
	// contains filtered or unexported fields
}

MultiSearch executes one or more searches in one roundtrip. See http://www.elasticsearch.org/guide/reference/api/multi-search/

func NewMultiSearchService 

func NewMultiSearchService(client *Client) *MultiSearchService

func (*MultiSearchService) Add 

func (s *MultiSearchService) Add(requests ...*SearchRequest) *MultiSearchService

func (*MultiSearchService) Do 

func (s *MultiSearchService) Do() (*MultiSearchResult, error)

func (*MultiSearchService) Index 

func (s *MultiSearchService) Index(index string) *MultiSearchService

func (*MultiSearchService) Indices 

func (s *MultiSearchService) Indices(indices ...string) *MultiSearchService

func (*MultiSearchService) Pretty 

func (s *MultiSearchService) Pretty(pretty bool) *MultiSearchService

type NestedAggregation 

type NestedAggregation struct {
	// contains filtered or unexported fields
}

NestedAggregation is a special single bucket aggregation that enables aggregating nested documents. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-aggregations-bucket-nested-aggregation.html

func NewNestedAggregation 

func NewNestedAggregation() NestedAggregation

func (NestedAggregation) Path 

func (a NestedAggregation) Path(path string) NestedAggregation

func (NestedAggregation) Source 

func (a NestedAggregation) Source() interface{}

func (NestedAggregation) SubAggregation 

func (a NestedAggregation) SubAggregation(name string, subAggregation Aggregation) NestedAggregation

type NestedFilter 

type NestedFilter struct {
	// contains filtered or unexported fields
}

A nested filter, works in a similar fashion to the nested query, except used as a filter. It follows exactly the same structure, but also allows to cache the results (set _cache to true), and have it named (set the _name value).

For details, see: http://www.elasticsearch.org/guide/reference/query-dsl/nested-filter/

func NewNestedFilter 

func NewNestedFilter(path string) NestedFilter

func (NestedFilter) Cache 

func (f NestedFilter) Cache(cache bool) NestedFilter

func (NestedFilter) CacheKey 

func (f NestedFilter) CacheKey(cacheKey string) NestedFilter

func (NestedFilter) Filter 

func (f NestedFilter) Filter(filter Filter) NestedFilter

func (NestedFilter) FilterName 

func (f NestedFilter) FilterName(filterName string) NestedFilter

func (NestedFilter) InnerHit 

func (f NestedFilter) InnerHit(innerHit *InnerHit) NestedFilter

func (NestedFilter) Join 

func (f NestedFilter) Join(join bool) NestedFilter

func (NestedFilter) Path 

func (f NestedFilter) Path(path string) NestedFilter

func (NestedFilter) Query 

func (f NestedFilter) Query(query Query) NestedFilter

func (NestedFilter) Source 

func (f NestedFilter) Source() interface{}

type NestedQuery 

type NestedQuery struct {
	// contains filtered or unexported fields
}

Nested query allows to query nested objects / docs (see nested mapping). The query is executed against the nested objects / docs as if they were indexed as separate docs (they are, internally) and resulting in the root parent doc (or parent nested mapping).

For more details, see: http://www.elasticsearch.org/guide/reference/query-dsl/nested-query/

func NewNestedQuery 

func NewNestedQuery(path string) NestedQuery

Creates a new nested_query query.

func (NestedQuery) Boost 

func (q NestedQuery) Boost(boost float32) NestedQuery

func (NestedQuery) Filter 

func (q NestedQuery) Filter(filter Filter) NestedQuery

func (NestedQuery) InnerHit 

func (q NestedQuery) InnerHit(innerHit *InnerHit) NestedQuery

func (NestedQuery) Path 

func (q NestedQuery) Path(path string) NestedQuery

func (NestedQuery) Query 

func (q NestedQuery) Query(query Query) NestedQuery

func (NestedQuery) QueryName 

func (q NestedQuery) QueryName(queryName string) NestedQuery

func (NestedQuery) ScoreMode 

func (q NestedQuery) ScoreMode(scoreMode string) NestedQuery

func (NestedQuery) Source 

func (q NestedQuery) Source() interface{}

Creates the query source for the nested_query query.

type NodesInfoNode 

type NodesInfoNode struct {
	// Name of the node, e.g. "Mister Fear"
	Name string `json:"name"`
	// TransportAddress, e.g. "inet[/127.0.0.1:9300]"
	TransportAddress string `json:"transport_address"`
	// Host is the host name, e.g. "macbookair"
	Host string `json:"host"`
	// IP is the IP address, e.g. "192.168.1.2"
	IP string `json:"ip"`
	// Version is the Elasticsearch version running on the node, e.g. "1.4.3"
	Version string `json:"version"`
	// Build is the Elasticsearch build, e.g. "36a29a7"
	Build string `json:"build"`
	// HTTPAddress, e.g. "inet[/127.0.0.1:9200]"
	HTTPAddress string `json:"http_address"`
	// HTTPSAddress, e.g. "inet[/127.0.0.1:9200]"
	HTTPSAddress string `json:"https_address"`

	// Settings of the node, e.g. paths and pidfile.
	Settings map[string]interface{} `json:"settings"`

	// OS information, e.g. CPU and memory.
	OS *NodesInfoNodeOS `json:"os"`

	// Process information, e.g. max file descriptors.
	Process *NodesInfoNodeProcess `json:"process"`

	// JVM information, e.g. VM version.
	JVM *NodesInfoNodeProcess `json:"jvm"`

	// ThreadPool information.
	ThreadPool *NodesInfoNodeThreadPool `json:"thread_pool"`

	// Network information.
	Network *NodesInfoNodeNetwork `json:"network"`

	// Network information.
	Transport *NodesInfoNodeTransport `json:"transport"`

	// HTTP information.
	HTTP *NodesInfoNodeHTTP `json:"http"`

	// Plugins information.
	Plugins []*NodesInfoNodePlugin `json:"plugins"`
}

type NodesInfoNodeHTTP 

type NodesInfoNodeHTTP struct {
	BoundAddress            string `json:"bound_address"`      // e.g. inet[/127.0.0.1:9300]
	PublishAddress          string `json:"publish_address"`    // e.g. inet[/127.0.0.1:9300]
	MaxContentLength        string `json:"max_content_length"` // e.g. "100mb"
	MaxContentLengthInBytes int64  `json:"max_content_length_in_bytes"`
}

type NodesInfoNodeJVM 

type NodesInfoNodeJVM struct {
	PID               int       `json:"pid"`        // process id, e.g. 87079
	Version           string    `json:"version"`    // e.g. "1.8.0_25"
	VMName            string    `json:"vm_name"`    // e.g. "Java HotSpot(TM) 64-Bit Server VM"
	VMVersion         string    `json:"vm_version"` // e.g. "25.25-b02"
	VMVendor          string    `json:"vm_vendor"`  // e.g. "Oracle Corporation"
	StartTime         time.Time `json:"start_time"` // e.g. "2015-01-03T15:18:30.982Z"
	StartTimeInMillis int64     `json:"start_time_in_millis"`

	// Mem information
	Mem struct {
		HeapInit           string `json:"heap_init"` // e.g. 1gb
		HeapInitInBytes    int    `json:"heap_init_in_bytes"`
		HeapMax            string `json:"heap_max"` // e.g. 4gb
		HeapMaxInBytes     int    `json:"heap_max_in_bytes"`
		NonHeapInit        string `json:"non_heap_init"` // e.g. 2.4mb
		NonHeapInitInBytes int    `json:"non_heap_init_in_bytes"`
		NonHeapMax         string `json:"non_heap_max"` // e.g. 0b
		NonHeapMaxInBytes  int    `json:"non_heap_max_in_bytes"`
		DirectMax          string `json:"direct_max"` // e.g. 4gb
		DirectMaxInBytes   int    `json:"direct_max_in_bytes"`
	} `json:"mem"`

	GCCollectors []string `json:"gc_collectors"` // e.g. ["ParNew"]
	MemoryPools  []string `json:"memory_pools"`  // e.g. ["Code Cache", "Metaspace"]
}

type NodesInfoNodeNetwork 

type NodesInfoNodeNetwork struct {
	RefreshInterval         string `json:"refresh_interval"`           // e.g. 1s
	RefreshIntervalInMillis int    `json:"refresh_interval_in_millis"` // e.g. 1000
	PrimaryInterface        struct {
		Address    string `json:"address"`     // e.g. 192.168.1.2
		Name       string `json:"name"`        // e.g. en0
		MACAddress string `json:"mac_address"` // e.g. 11:22:33:44:55:66
	} `json:"primary_interface"`
}

type NodesInfoNodeOS 

type NodesInfoNodeOS struct {
	RefreshInterval         string `json:"refresh_interval"`           // e.g. 1s
	RefreshIntervalInMillis int    `json:"refresh_interval_in_millis"` // e.g. 1000
	AvailableProcessors     int    `json:"available_processors"`       // e.g. 4

	// CPU information
	CPU struct {
		Vendor           string `json:"vendor"`              // e.g. Intel
		Model            string `json:"model"`               // e.g. iMac15,1
		MHz              int    `json:"mhz"`                 // e.g. 3500
		TotalCores       int    `json:"total_cores"`         // e.g. 4
		TotalSockets     int    `json:"total_sockets"`       // e.g. 4
		CoresPerSocket   int    `json:"cores_per_socket"`    // e.g. 16
		CacheSizeInBytes int    `json:"cache_size_in_bytes"` // e.g. 256
	} `json:"cpu"`

	// Mem information
	Mem struct {
		Total        string `json:"total"`          // e.g. 16gb
		TotalInBytes int    `json:"total_in_bytes"` // e.g. 17179869184
	} `json:"mem"`

	// Swap information
	Swap struct {
		Total        string `json:"total"`          // e.g. 1gb
		TotalInBytes int    `json:"total_in_bytes"` // e.g. 1073741824
	} `json:"swap"`
}

type NodesInfoNodePlugin 

type NodesInfoNodePlugin struct {
	Name        string `json:"name"`
	Description string `json:"description"`
	Site        bool   `json:"site"`
	JVM         bool   `json:"jvm"`
	URL         string `json:"url"` // e.g. /_plugin/dummy/
}

type NodesInfoNodeProcess 

type NodesInfoNodeProcess struct {
	RefreshInterval         string `json:"refresh_interval"`           // e.g. 1s
	RefreshIntervalInMillis int    `json:"refresh_interval_in_millis"` // e.g. 1000
	ID                      int    `json:"id"`                         // process id, e.g. 87079
	MaxFileDescriptors      int    `json:"max_file_descriptors"`       // e.g. 32768
	Mlockall                bool   `json:"mlockall"`                   // e.g. false
}

type NodesInfoNodeThreadPool 

type NodesInfoNodeThreadPool struct {
	Percolate  *NodesInfoNodeThreadPoolSection `json:"percolate"`
	Bench      *NodesInfoNodeThreadPoolSection `json:"bench"`
	Listener   *NodesInfoNodeThreadPoolSection `json:"listener"`
	Index      *NodesInfoNodeThreadPoolSection `json:"index"`
	Refresh    *NodesInfoNodeThreadPoolSection `json:"refresh"`
	Suggest    *NodesInfoNodeThreadPoolSection `json:"suggest"`
	Generic    *NodesInfoNodeThreadPoolSection `json:"generic"`
	Warmer     *NodesInfoNodeThreadPoolSection `json:"warmer"`
	Search     *NodesInfoNodeThreadPoolSection `json:"search"`
	Flush      *NodesInfoNodeThreadPoolSection `json:"flush"`
	Optimize   *NodesInfoNodeThreadPoolSection `json:"optimize"`
	Management *NodesInfoNodeThreadPoolSection `json:"management"`
	Get        *NodesInfoNodeThreadPoolSection `json:"get"`
	Merge      *NodesInfoNodeThreadPoolSection `json:"merge"`
	Bulk       *NodesInfoNodeThreadPoolSection `json:"bulk"`
	Snapshot   *NodesInfoNodeThreadPoolSection `json:"snapshot"`
}

type NodesInfoNodeThreadPoolSection 

type NodesInfoNodeThreadPoolSection struct {
	Type      string      `json:"type"`       // e.g. fixed
	Min       int         `json:"min"`        // e.g. 4
	Max       int         `json:"max"`        // e.g. 4
	KeepAlive string      `json:"keep_alive"` // e.g. "5m"
	QueueSize interface{} `json:"queue_size"` // e.g. "1k" or -1
}

type NodesInfoNodeTransport 

type NodesInfoNodeTransport struct {
	BoundAddress   string `json:"bound_address"`   // e.g. inet[/127.0.0.1:9300]
	PublishAddress string `json:"publish_address"` // e.g. inet[/127.0.0.1:9300]
}

type NodesInfoResponse 

type NodesInfoResponse struct {
	ClusterName string                    `json:"cluster_name"`
	Nodes       map[string]*NodesInfoNode `json:"nodes"`
}

NodesInfoResponse is the response of NodesInfoService.Do.

type NodesInfoService 

type NodesInfoService struct {
	// contains filtered or unexported fields
}

NodesInfoService allows to retrieve one or more or all of the cluster nodes information. It is documented at http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/cluster-nodes-info.html.

func NewNodesInfoService 

func NewNodesInfoService(client *Client) *NodesInfoService

NewNodesInfoService creates a new NodesInfoService.

func (*NodesInfoService) Do 

func (s *NodesInfoService) Do() (*NodesInfoResponse, error)

Do executes the operation.

func (*NodesInfoService) FlatSettings 

func (s *NodesInfoService) FlatSettings(flatSettings bool) *NodesInfoService

FlatSettings returns settings in flat format (default: false).

func (*NodesInfoService) Human 

func (s *NodesInfoService) Human(human bool) *NodesInfoService

Human indicates whether to return time and byte values in human-readable format.

func (*NodesInfoService) Metric 

func (s *NodesInfoService) Metric(metric ...string) *NodesInfoService

Metric is a list of metrics you wish returned. Leave empty to return all. Valid metrics are: settings, os, process, jvm, thread_pool, network, transport, http, and plugins.

func (*NodesInfoService) NodeId 

func (s *NodesInfoService) NodeId(nodeId ...string) *NodesInfoService

NodeId is a list of node IDs or names to limit the returned information. Use "_local" to return information from the node you're connecting to, leave empty to get information from all nodes.

func (*NodesInfoService) Pretty 

func (s *NodesInfoService) Pretty(pretty bool) *NodesInfoService

Pretty indicates whether to indent the returned JSON.

func (*NodesInfoService) Validate 

func (s *NodesInfoService) Validate() error

Validate checks if the operation is valid.

type NotFilter 

type NotFilter struct {
	// contains filtered or unexported fields
}

A filter that filters out matched documents using a query. Can be placed within queries that accept a filter. For details, see: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-not-filter.html#query-dsl-not-filter.

func NewNotFilter 

func NewNotFilter(filter Filter) NotFilter

func (NotFilter) Cache 

func (f NotFilter) Cache(cache bool) NotFilter

func (NotFilter) CacheKey 

func (f NotFilter) CacheKey(cacheKey string) NotFilter

func (NotFilter) FilterName 

func (f NotFilter) FilterName(filterName string) NotFilter

func (NotFilter) Source 

func (f NotFilter) Source() interface{}

type OpenIndexResponse 

type OpenIndexResponse struct {
	Acknowledged bool `json:"acknowledged"`
}

OpenIndexResponse is the response of OpenIndexService.Do.

type OpenIndexService 

type OpenIndexService struct {
	// contains filtered or unexported fields
}

OpenIndexService opens an index. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.4/indices-open-close.html.

func NewOpenIndexService 

func NewOpenIndexService(client *Client) *OpenIndexService

NewOpenIndexService creates a new OpenIndexService.

func (*OpenIndexService) AllowNoIndices 

func (s *OpenIndexService) AllowNoIndices(allowNoIndices bool) *OpenIndexService

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 (*OpenIndexService) Do 

func (s *OpenIndexService) Do() (*OpenIndexResponse, error)

Do executes the operation.

func (*OpenIndexService) ExpandWildcards 

func (s *OpenIndexService) ExpandWildcards(expandWildcards string) *OpenIndexService

ExpandWildcards indicates whether to expand wildcard expression to concrete indices that are open, closed or both..

func (*OpenIndexService) IgnoreUnavailable 

func (s *OpenIndexService) IgnoreUnavailable(ignoreUnavailable bool) *OpenIndexService

IgnoreUnavailable indicates whether specified concrete indices should be ignored when unavailable (missing or closed).

func (*OpenIndexService) Index 

func (s *OpenIndexService) Index(index string) *OpenIndexService

Index is the name of the index to open.

func (*OpenIndexService) MasterTimeout 

func (s *OpenIndexService) MasterTimeout(masterTimeout string) *OpenIndexService

MasterTimeout specifies the timeout for connection to master.

func (*OpenIndexService) Timeout 

func (s *OpenIndexService) Timeout(timeout string) *OpenIndexService

Timeout is an explicit operation timeout.

func (*OpenIndexService) Validate 

func (s *OpenIndexService) Validate() error

Validate checks if the operation is valid.

type OptimizeResult 

type OptimizeResult struct {
	Shards shardsInfo `json:"_shards,omitempty"`
}

type OptimizeService 

type OptimizeService struct {
	// contains filtered or unexported fields
}

func NewOptimizeService 

func NewOptimizeService(client *Client) *OptimizeService

func (*OptimizeService) Do 

func (s *OptimizeService) Do() (*OptimizeResult, error)

func (*OptimizeService) Flush 

func (s *OptimizeService) Flush(flush bool) *OptimizeService

func (*OptimizeService) Force 

func (s *OptimizeService) Force(force bool) *OptimizeService

func (*OptimizeService) Index 

func (s *OptimizeService) Index(index string) *OptimizeService

func (*OptimizeService) Indices 

func (s *OptimizeService) Indices(indices ...string) *OptimizeService

func (*OptimizeService) MaxNumSegments 

func (s *OptimizeService) MaxNumSegments(maxNumSegments int) *OptimizeService

func (*OptimizeService) OnlyExpungeDeletes 

func (s *OptimizeService) OnlyExpungeDeletes(onlyExpungeDeletes bool) *OptimizeService

func (*OptimizeService) Pretty 

func (s *OptimizeService) Pretty(pretty bool) *OptimizeService

func (*OptimizeService) WaitForMerge 

func (s *OptimizeService) WaitForMerge(waitForMerge bool) *OptimizeService

type OrFilter 

type OrFilter struct {
	// contains filtered or unexported fields
}

A filter that matches documents using OR boolean operator on other queries. Can be placed within queries that accept a filter. For details, see: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-or-filter.html

func NewOrFilter 

func NewOrFilter(filters ...Filter) OrFilter

func (OrFilter) Add 

func (f OrFilter) Add(filter Filter) OrFilter

func (OrFilter) Cache 

func (f OrFilter) Cache(cache bool) OrFilter

func (OrFilter) CacheKey 

func (f OrFilter) CacheKey(cacheKey string) OrFilter

func (OrFilter) FilterName 

func (f OrFilter) FilterName(filterName string) OrFilter

func (OrFilter) Source 

func (f OrFilter) Source() interface{}

type PartialField 

type PartialField struct {
	Name string
	// contains filtered or unexported fields
}

func NewPartialField 

func NewPartialField(name string, includes, excludes []string) *PartialField

func (*PartialField) Source 

func (f *PartialField) Source() interface{}

type PercentileRanksAggregation 

type PercentileRanksAggregation struct {
	// contains filtered or unexported fields
}

PercentileRanksAggregation See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-metrics-percentile-rank-aggregation.html

func NewPercentileRanksAggregation 

func NewPercentileRanksAggregation() PercentileRanksAggregation

func (PercentileRanksAggregation) Compression 

func (a PercentileRanksAggregation) Compression(compression float64) PercentileRanksAggregation

func (PercentileRanksAggregation) Estimator 

func (a PercentileRanksAggregation) Estimator(estimator string) PercentileRanksAggregation

func (PercentileRanksAggregation) Field 

func (a PercentileRanksAggregation) Field(field string) PercentileRanksAggregation

func (PercentileRanksAggregation) Format 

func (a PercentileRanksAggregation) Format(format string) PercentileRanksAggregation

func (PercentileRanksAggregation) Lang 

func (a PercentileRanksAggregation) Lang(lang string) PercentileRanksAggregation

func (PercentileRanksAggregation) Param 

func (a PercentileRanksAggregation) Param(name string, value interface{}) PercentileRanksAggregation

func (PercentileRanksAggregation) Script 

func (a PercentileRanksAggregation) Script(script string) PercentileRanksAggregation

func (PercentileRanksAggregation) ScriptFile 

func (a PercentileRanksAggregation) ScriptFile(scriptFile string) PercentileRanksAggregation

func (PercentileRanksAggregation) Source 

func (a PercentileRanksAggregation) Source() interface{}

func (PercentileRanksAggregation) SubAggregation 

func (a PercentileRanksAggregation) SubAggregation(name string, subAggregation Aggregation) PercentileRanksAggregation

func (PercentileRanksAggregation) Values 

func (a PercentileRanksAggregation) Values(values ...float64) PercentileRanksAggregation

type PercentilesAggregation 

type PercentilesAggregation struct {
	// contains filtered or unexported fields
}

PercentilesAggregation See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-metrics-percentile-aggregation.html

func NewPercentilesAggregation 

func NewPercentilesAggregation() PercentilesAggregation

func (PercentilesAggregation) Compression 

func (a PercentilesAggregation) Compression(compression float64) PercentilesAggregation

func (PercentilesAggregation) Estimator 

func (a PercentilesAggregation) Estimator(estimator string) PercentilesAggregation

func (PercentilesAggregation) Field 

func (a PercentilesAggregation) Field(field string) PercentilesAggregation

func (PercentilesAggregation) Format 

func (a PercentilesAggregation) Format(format string) PercentilesAggregation

func (PercentilesAggregation) Lang 

func (a PercentilesAggregation) Lang(lang string) PercentilesAggregation

func (PercentilesAggregation) Param 

func (a PercentilesAggregation) Param(name string, value interface{}) PercentilesAggregation

func (PercentilesAggregation) Percentiles 

func (a PercentilesAggregation) Percentiles(percentiles ...float64) PercentilesAggregation

func (PercentilesAggregation) Script 

func (a PercentilesAggregation) Script(script string) PercentilesAggregation

func (PercentilesAggregation) ScriptFile 

func (a PercentilesAggregation) ScriptFile(scriptFile string) PercentilesAggregation

func (PercentilesAggregation) Source 

func (a PercentilesAggregation) Source() interface{}

func (PercentilesAggregation) SubAggregation 

func (a PercentilesAggregation) SubAggregation(name string, subAggregation Aggregation) PercentilesAggregation

type PercolateMatch 

type PercolateMatch struct {
	Index string  `json:"_index,omitempty"`
	Id    string  `json:"_id"`
	Score float64 `json:"_score,omitempty"`
}

PercolateMatch returns a single match in a PercolateResponse.

type PercolateResponse 

type PercolateResponse struct {
	TookInMillis int64             `json:"took"`  // search time in milliseconds
	Total        int64             `json:"total"` // total matches
	Matches      []*PercolateMatch `json:"matches,omitempty"`
	Facets       SearchFacets      `json:"facets,omitempty"`       // results from facets
	Aggregations Aggregations      `json:"aggregations,omitempty"` // results from aggregations
}

PercolateResponse is the response of PercolateService.Do.

type PercolateService 

type PercolateService struct {
	// contains filtered or unexported fields
}

PercolateService is documented at http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.4/search-percolate.html.

func NewPercolateService 

func NewPercolateService(client *Client) *PercolateService

NewPercolateService creates a new PercolateService.

func (*PercolateService) AllowNoIndices 

func (s *PercolateService) AllowNoIndices(allowNoIndices bool) *PercolateService

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 (*PercolateService) BodyJson 

func (s *PercolateService) BodyJson(body interface{}) *PercolateService

BodyJson is the percolator request definition using the percolate DSL.

func (*PercolateService) BodyString 

func (s *PercolateService) BodyString(body string) *PercolateService

BodyString is the percolator request definition using the percolate DSL.

func (*PercolateService) Do 

func (s *PercolateService) Do() (*PercolateResponse, error)

Do executes the operation.

func (*PercolateService) Doc 

func (s *PercolateService) Doc(doc interface{}) *PercolateService

Doc wraps the given document into the "doc" key of the body.

func (*PercolateService) ExpandWildcards 

func (s *PercolateService) ExpandWildcards(expandWildcards string) *PercolateService

ExpandWildcards indicates whether to expand wildcard expressions to concrete indices that are open, closed or both.

func (*PercolateService) Id 

func (s *PercolateService) Id(id string) *PercolateService

Id is to substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.

func (*PercolateService) IgnoreUnavailable 

func (s *PercolateService) IgnoreUnavailable(ignoreUnavailable bool) *PercolateService

IgnoreUnavailable indicates whether specified concrete indices should be ignored when unavailable (missing or closed).

func (*PercolateService) Index 

func (s *PercolateService) Index(index string) *PercolateService

Index is the name of the index of the document being percolated.

func (*PercolateService) PercolateFormat 

func (s *PercolateService) PercolateFormat(percolateFormat string) *PercolateService

PercolateFormat indicates whether to return an array of matching query IDs instead of objects.

func (*PercolateService) PercolateIndex 

func (s *PercolateService) PercolateIndex(percolateIndex string) *PercolateService

PercolateIndex is the index to percolate the document into. Defaults to index.

func (*PercolateService) PercolatePreference 

func (s *PercolateService) PercolatePreference(percolatePreference string) *PercolateService

PercolatePreference defines which shard to prefer when executing the percolate request.

func (*PercolateService) PercolateRouting 

func (s *PercolateService) PercolateRouting(percolateRouting string) *PercolateService

PercolateRouting is the routing value to use when percolating the existing document.

func (*PercolateService) PercolateType 

func (s *PercolateService) PercolateType(percolateType string) *PercolateService

PercolateType is the type to percolate document into. Defaults to type.

func (*PercolateService) Preference 

func (s *PercolateService) Preference(preference string) *PercolateService

Preference specifies the node or shard the operation should be performed on (default: random).

func (*PercolateService) Pretty 

func (s *PercolateService) Pretty(pretty bool) *PercolateService

Pretty indicates that the JSON response be indented and human readable.

func (*PercolateService) Routing 

func (s *PercolateService) Routing(routing []string) *PercolateService

Routing is a list of specific routing values.

func (*PercolateService) Source 

func (s *PercolateService) Source(source string) *PercolateService

Source is the URL-encoded request definition.

func (*PercolateService) Type 

func (s *PercolateService) Type(typ string) *PercolateService

Type is the type of the document being percolated.

func (*PercolateService) Validate 

func (s *PercolateService) Validate() error

Validate checks if the operation is valid.

func (*PercolateService) Version 

func (s *PercolateService) Version(version interface{}) *PercolateService

Version is an explicit version number for concurrency control.

func (*PercolateService) VersionType 

func (s *PercolateService) VersionType(versionType string) *PercolateService

VersionType is the specific version type.

type PhraseSuggester 

type PhraseSuggester struct {
	Suggester
	// contains filtered or unexported fields
}

For more details, see http://www.elasticsearch.org/guide/reference/api/search/phrase-suggest/

func NewPhraseSuggester 

func NewPhraseSuggester(name string) PhraseSuggester

Creates a new phrase suggester.

func (PhraseSuggester) Analyzer 

func (q PhraseSuggester) Analyzer(analyzer string) PhraseSuggester

func (PhraseSuggester) CandidateGenerator 

func (q PhraseSuggester) CandidateGenerator(generator CandidateGenerator) PhraseSuggester

func (PhraseSuggester) CandidateGenerators 

func (q PhraseSuggester) CandidateGenerators(generators ...CandidateGenerator) PhraseSuggester

func (PhraseSuggester) ClearCandidateGenerator 

func (q PhraseSuggester) ClearCandidateGenerator() PhraseSuggester

func (PhraseSuggester) CollateFilter 

func (q PhraseSuggester) CollateFilter(collateFilter string) PhraseSuggester

func (PhraseSuggester) CollateParams 

func (q PhraseSuggester) CollateParams(collateParams map[string]interface{}) PhraseSuggester

func (PhraseSuggester) CollatePreference 

func (q PhraseSuggester) CollatePreference(collatePreference string) PhraseSuggester

func (PhraseSuggester) CollatePrune 

func (q PhraseSuggester) CollatePrune(collatePrune bool) PhraseSuggester

func (PhraseSuggester) CollateQuery 

func (q PhraseSuggester) CollateQuery(collateQuery string) PhraseSuggester

func (PhraseSuggester) Confidence 

func (q PhraseSuggester) Confidence(confidence float32) PhraseSuggester

func (PhraseSuggester) ContextQueries 

func (q PhraseSuggester) ContextQueries(queries ...SuggesterContextQuery) PhraseSuggester

func (PhraseSuggester) ContextQuery 

func (q PhraseSuggester) ContextQuery(query SuggesterContextQuery) PhraseSuggester

func (PhraseSuggester) Field 

func (q PhraseSuggester) Field(field string) PhraseSuggester

func (PhraseSuggester) ForceUnigrams 

func (q PhraseSuggester) ForceUnigrams(forceUnigrams bool) PhraseSuggester

func (PhraseSuggester) GramSize 

func (q PhraseSuggester) GramSize(gramSize int) PhraseSuggester

func (PhraseSuggester) Highlight 

func (q PhraseSuggester) Highlight(preTag, postTag string) PhraseSuggester

func (PhraseSuggester) MaxErrors 

func (q PhraseSuggester) MaxErrors(maxErrors float32) PhraseSuggester

func (PhraseSuggester) Name 

func (q PhraseSuggester) Name() string

func (PhraseSuggester) RealWordErrorLikelihood 

func (q PhraseSuggester) RealWordErrorLikelihood(realWordErrorLikelihood float32) PhraseSuggester

func (PhraseSuggester) Separator 

func (q PhraseSuggester) Separator(separator string) PhraseSuggester

func (PhraseSuggester) ShardSize 

func (q PhraseSuggester) ShardSize(shardSize int) PhraseSuggester

func (PhraseSuggester) Size 

func (q PhraseSuggester) Size(size int) PhraseSuggester

func (PhraseSuggester) SmoothingModel 

func (q PhraseSuggester) SmoothingModel(smoothingModel SmoothingModel) PhraseSuggester

func (PhraseSuggester) Source 

func (q PhraseSuggester) Source(includeName bool) interface{}

Creates the source for the phrase suggester.

func (PhraseSuggester) Text 

func (q PhraseSuggester) Text(text string) PhraseSuggester

func (PhraseSuggester) TokenLimit 

func (q PhraseSuggester) TokenLimit(tokenLimit int) PhraseSuggester

type PingResult 

type PingResult struct {
	Status      int    `json:"status"`
	Name        string `json:"name"`
	ClusterName string `json:"cluster_name"`
	Version     struct {
		Number         string `json:"number"`
		BuildHash      string `json:"build_hash"`
		BuildTimestamp string `json:"build_timestamp"`
		BuildSnapshot  bool   `json:"build_snapshot"`
		LuceneVersion  string `json:"lucene_version"`
	} `json:"version"`
	TagLine string `json:"tagline"`
}

PingResult is the result returned from querying the Elasticsearch server.

type PingService 

type PingService struct {
	// contains filtered or unexported fields
}

PingService checks if an Elasticsearch server on a given URL is alive. When asked for, it can also return various information about the Elasticsearch server, e.g. the Elasticsearch version number.

Ping simply starts a HTTP GET request to the URL of the server. If the server responds with HTTP Status code 200 OK, the server is alive.

func NewPingService 

func NewPingService(client *Client) *PingService

func (*PingService) Do 

func (s *PingService) Do() (*PingResult, int, error)

Do returns the PingResult, the HTTP status code of the Elasticsearch server, and an error.

func (*PingService) HttpHeadOnly 

func (s *PingService) HttpHeadOnly(httpHeadOnly bool) *PingService

HeadOnly makes the service to only return the status code in Do; the PingResult will be nil.

func (*PingService) Pretty 

func (s *PingService) Pretty(pretty bool) *PingService

func (*PingService) Timeout 

func (s *PingService) Timeout(timeout string) *PingService

func (*PingService) URL 

func (s *PingService) URL(url string) *PingService

type PrefixFilter 

type PrefixFilter struct {
	Filter
	// contains filtered or unexported fields
}

Filters documents that have fiels containing terms with a specified prefix (not analyzed). For details, see: http://www.elasticsearch.org/guide/reference/query-dsl/prefix-filter.html

func NewPrefixFilter 

func NewPrefixFilter(name string, prefix string) PrefixFilter

func (PrefixFilter) Cache 

func (f PrefixFilter) Cache(cache bool) PrefixFilter

func (PrefixFilter) CacheKey 

func (f PrefixFilter) CacheKey(cacheKey string) PrefixFilter

func (PrefixFilter) FilterName 

func (f PrefixFilter) FilterName(filterName string) PrefixFilter

func (PrefixFilter) Source 

func (f PrefixFilter) Source() interface{}

type PrefixQuery 

type PrefixQuery struct {
	Query
	// contains filtered or unexported fields
}

Matches documents that have fields containing terms with a specified prefix (not analyzed). For more details, see http://www.elasticsearch.org/guide/reference/query-dsl/prefix-query.html

func NewPrefixQuery 

func NewPrefixQuery(name string, prefix string) PrefixQuery

Creates a new prefix query.

func (PrefixQuery) Boost 

func (q PrefixQuery) Boost(boost float32) PrefixQuery

func (PrefixQuery) QueryName 

func (q PrefixQuery) QueryName(queryName string) PrefixQuery

func (PrefixQuery) Rewrite 

func (q PrefixQuery) Rewrite(rewrite string) PrefixQuery

func (PrefixQuery) Source 

func (q PrefixQuery) Source() interface{}

Creates the query source for the prefix query.

type PutMappingResponse 

type PutMappingResponse struct {
	Acknowledged bool `json:"acknowledged"`
}

PutMappingResponse is the response of PutMappingService.Do.

type PutMappingService 

type PutMappingService struct {
	// contains filtered or unexported fields
}

PutMappingService allows to register specific mapping definition for a specific type. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-put-mapping.html.

func NewPutMappingService 

func NewPutMappingService(client *Client) *PutMappingService

NewPutMappingService creates a new PutMappingService.

func (*PutMappingService) AllowNoIndices 

func (s *PutMappingService) AllowNoIndices(allowNoIndices bool) *PutMappingService

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 (*PutMappingService) BodyJson 

func (s *PutMappingService) BodyJson(mapping map[string]interface{}) *PutMappingService

BodyJson contains the mapping definition.

func (*PutMappingService) BodyString 

func (s *PutMappingService) BodyString(mapping string) *PutMappingService

BodyString is the mapping definition serialized as a string.

func (*PutMappingService) Do 

func (s *PutMappingService) Do() (*PutMappingResponse, error)

Do executes the operation.

func (*PutMappingService) ExpandWildcards 

func (s *PutMappingService) ExpandWildcards(expandWildcards string) *PutMappingService

ExpandWildcards indicates whether to expand wildcard expression to concrete indices that are open, closed or both.

func (*PutMappingService) IgnoreConflicts 

func (s *PutMappingService) IgnoreConflicts(ignoreConflicts bool) *PutMappingService

IgnoreConflicts specifies whether to ignore conflicts while updating the mapping (default: false).

func (*PutMappingService) IgnoreUnavailable 

func (s *PutMappingService) IgnoreUnavailable(ignoreUnavailable bool) *PutMappingService

IgnoreUnavailable indicates whether specified concrete indices should be ignored when unavailable (missing or closed).

func (*PutMappingService) Index 

func (s *PutMappingService) Index(index ...string) *PutMappingService

Index is a list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices.

func (*PutMappingService) MasterTimeout 

func (s *PutMappingService) MasterTimeout(masterTimeout string) *PutMappingService

MasterTimeout specifies the timeout for connection to master.

func (*PutMappingService) Pretty 

func (s *PutMappingService) Pretty(pretty bool) *PutMappingService

Pretty indicates that the JSON response be indented and human readable.

func (*PutMappingService) Timeout 

func (s *PutMappingService) Timeout(timeout string) *PutMappingService

Timeout is an explicit operation timeout.

func (*PutMappingService) Type 

func (s *PutMappingService) Type(typ string) *PutMappingService

Type is the name of the document type.

func (*PutMappingService) Validate 

func (s *PutMappingService) Validate() error

Validate checks if the operation is valid.

type PutTemplateResponse 

type PutTemplateResponse struct {
	Id      string `json:"_id"`
	Version int    `json:"_version"`
	Created bool   `json:"created"`
}

PutTemplateResponse is the response of PutTemplateService.Do.

type PutTemplateService 

type PutTemplateService struct {
	// contains filtered or unexported fields
}

PutTemplateService creates or updates a search template. The documentation can be found at http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html.

Example 
package main

import (
	"fmt"

	elastic "gopkg.in/olivere/elastic.v2"
)

func main() {
	client, err := elastic.NewClient()
	if err != nil {
		panic(err)
	}

	// Create search template
	tmpl := `{"template":{"query":{"match":{"title":"{{query_string}}"}}}}`

	// Create template
	resp, err := client.PutTemplate().
		Id("my-search-template"). // Name of the template
		BodyString(tmpl).         // Search template itself
		Do()                      // Execute
	if err != nil {
		panic(err)
	}
	if resp.Created {
		fmt.Println("search template created")
	}
}

Output:

func NewPutTemplateService 

func NewPutTemplateService(client *Client) *PutTemplateService

NewPutTemplateService creates a new PutTemplateService.

func (*PutTemplateService) BodyJson 

func (s *PutTemplateService) BodyJson(body interface{}) *PutTemplateService

BodyJson is the document as a JSON serializable object.

func (*PutTemplateService) BodyString 

func (s *PutTemplateService) BodyString(body string) *PutTemplateService

BodyString is the document as a string.

func (*PutTemplateService) Do 

func (s *PutTemplateService) Do() (*PutTemplateResponse, error)

Do executes the operation.

func (*PutTemplateService) Id 

func (s *PutTemplateService) Id(id string) *PutTemplateService

Id is the template ID.

func (*PutTemplateService) OpType 

func (s *PutTemplateService) OpType(opType string) *PutTemplateService

OpType is an explicit operation type.

func (*PutTemplateService) Validate 

func (s *PutTemplateService) Validate() error

Validate checks if the operation is valid.

func (*PutTemplateService) Version 

func (s *PutTemplateService) Version(version int) *PutTemplateService

Version is an explicit version number for concurrency control.

func (*PutTemplateService) VersionType 

func (s *PutTemplateService) VersionType(versionType string) *PutTemplateService

VersionType is a specific version type.

type PutWarmerResponse 

type PutWarmerResponse struct {
	Acknowledged bool `json:"acknowledged"`
}

PutWarmerResponse is the response of IndicesPutWarmerService.Do.

type Query 

type Query interface {
	Source() interface{}
}

Represents the generic query interface. A querys' only purpose is to return the source of the query as a JSON-serializable object. Returning a map[string]interface{} will do.

type QueryFacet 

type QueryFacet struct {
	// contains filtered or unexported fields
}

Query Facet See: http://www.elasticsearch.org/guide/reference/api/search/facets/query-facet.html

func NewQueryFacet 

func NewQueryFacet() QueryFacet

func (QueryFacet) FacetFilter 

func (f QueryFacet) FacetFilter(filter Facet) QueryFacet

func (QueryFacet) Global 

func (f QueryFacet) Global(global bool) QueryFacet

func (QueryFacet) Mode 

func (f QueryFacet) Mode(mode string) QueryFacet

func (QueryFacet) Nested 

func (f QueryFacet) Nested(nested string) QueryFacet

func (QueryFacet) Query 

func (f QueryFacet) Query(query Query) QueryFacet

func (QueryFacet) Source 

func (f QueryFacet) Source() interface{}

type QueryFilter 

type QueryFilter struct {
	Filter
	// contains filtered or unexported fields
}

QueryFilter wraps any query to be used as a filter. It can be placed within queries that accept a filter. For details, see: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-query-filter.html

func NewQueryFilter 

func NewQueryFilter(query Query) QueryFilter

func (QueryFilter) Cache 

func (f QueryFilter) Cache(cache bool) QueryFilter

func (QueryFilter) FilterName 

func (f QueryFilter) FilterName(filterName string) QueryFilter

func (QueryFilter) Name 

func (f QueryFilter) Name(name string) QueryFilter

func (QueryFilter) Query 

func (f QueryFilter) Query(query Query) QueryFilter

func (QueryFilter) Source 

func (f QueryFilter) Source() interface{}

type QueryRescorer 

type QueryRescorer struct {
	// contains filtered or unexported fields
}

func NewQueryRescorer 

func NewQueryRescorer(query Query) *QueryRescorer

func (*QueryRescorer) Name 

func (r *QueryRescorer) Name() string

func (*QueryRescorer) QueryWeight 

func (r *QueryRescorer) QueryWeight(queryWeight float64) *QueryRescorer

func (*QueryRescorer) RescoreQueryWeight 

func (r *QueryRescorer) RescoreQueryWeight(rescoreQueryWeight float64) *QueryRescorer

func (*QueryRescorer) ScoreMode 

func (r *QueryRescorer) ScoreMode(scoreMode string) *QueryRescorer

func (*QueryRescorer) Source 

func (r *QueryRescorer) Source() interface{}

type QueryStringQuery 

type QueryStringQuery struct {
	Query
	// contains filtered or unexported fields
}

A query that uses the query parser in order to parse its content. For more details, see http://www.elasticsearch.org/guide/reference/query-dsl/query-string-query.html

func NewQueryStringQuery 

func NewQueryStringQuery(queryString string) QueryStringQuery

Creates a new query string query.

func (QueryStringQuery) AllowLeadingWildcard 

func (q QueryStringQuery) AllowLeadingWildcard(allowLeadingWildcard bool) QueryStringQuery

func (QueryStringQuery) AnalyzeWildcard 

func (q QueryStringQuery) AnalyzeWildcard(analyzeWildcard bool) QueryStringQuery

func (QueryStringQuery) Analyzer 

func (q QueryStringQuery) Analyzer(analyzer string) QueryStringQuery

func (QueryStringQuery) AutoGeneratePhraseQueries 

func (q QueryStringQuery) AutoGeneratePhraseQueries(autoGeneratePhraseQueries bool) QueryStringQuery

func (QueryStringQuery) Boost 

func (q QueryStringQuery) Boost(boost float32) QueryStringQuery

func (QueryStringQuery) DefaultField 

func (q QueryStringQuery) DefaultField(defaultField string) QueryStringQuery

func (QueryStringQuery) DefaultOperator 

func (q QueryStringQuery) DefaultOperator(operator string) QueryStringQuery

func (QueryStringQuery) EnablePositionIncrements 

func (q QueryStringQuery) EnablePositionIncrements(enablePositionIncrements bool) QueryStringQuery

func (QueryStringQuery) Field 

func (q QueryStringQuery) Field(field string) QueryStringQuery

func (QueryStringQuery) FieldWithBoost 

func (q QueryStringQuery) FieldWithBoost(field string, boost float32) QueryStringQuery

func (QueryStringQuery) FuzzyMaxExpansions 

func (q QueryStringQuery) FuzzyMaxExpansions(fuzzyMaxExpansions int) QueryStringQuery

func (QueryStringQuery) FuzzyMinSim 

func (q QueryStringQuery) FuzzyMinSim(fuzzyMinSim float32) QueryStringQuery

func (QueryStringQuery) FuzzyRewrite 

func (q QueryStringQuery) FuzzyRewrite(fuzzyRewrite string) QueryStringQuery

func (QueryStringQuery) Lenient 

func (q QueryStringQuery) Lenient(lenient bool) QueryStringQuery

func (QueryStringQuery) LowercaseExpandedTerms 

func (q QueryStringQuery) LowercaseExpandedTerms(lowercaseExpandedTerms bool) QueryStringQuery

func (QueryStringQuery) MaxDeterminizedState 

func (q QueryStringQuery) MaxDeterminizedState(maxDeterminizedStates int) QueryStringQuery

MaxDeterminizedState protects against too-difficult regular expression queries.

func (QueryStringQuery) MinimumShouldMatch 

func (q QueryStringQuery) MinimumShouldMatch(minimumShouldMatch string) QueryStringQuery

func (QueryStringQuery) PhraseSlop 

func (q QueryStringQuery) PhraseSlop(phraseSlop int) QueryStringQuery

func (QueryStringQuery) QuoteAnalyzer 

func (q QueryStringQuery) QuoteAnalyzer(quoteAnalyzer string) QueryStringQuery

func (QueryStringQuery) QuoteFieldSuffix 

func (q QueryStringQuery) QuoteFieldSuffix(quoteFieldSuffix string) QueryStringQuery

func (QueryStringQuery) Rewrite 

func (q QueryStringQuery) Rewrite(rewrite string) QueryStringQuery

func (QueryStringQuery) Source 

func (q QueryStringQuery) Source() interface{}

Creates the query source for the query string query.

func (QueryStringQuery) TieBreaker 

func (q QueryStringQuery) TieBreaker(tieBreaker float32) QueryStringQuery

func (QueryStringQuery) TimeZone 

func (q QueryStringQuery) TimeZone(timeZone string) QueryStringQuery

TimeZone can be used to automatically adjust to/from fields using a timezone. Only used with date fields, of course.

func (QueryStringQuery) UseDisMax 

func (q QueryStringQuery) UseDisMax(useDisMax bool) QueryStringQuery

type RandomFunction 

type RandomFunction struct {
	// contains filtered or unexported fields
}

RandomFunction builds a random score function. See https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-function-score-query.html#_random for details.

func NewRandomFunction 

func NewRandomFunction() RandomFunction

NewRandomFunction initializes and returns a new RandomFunction.

func (RandomFunction) GetWeight 

func (fn RandomFunction) GetWeight() *float64

GetWeight returns the adjusted score. It is part of the ScoreFunction interface. Returns nil if weight is not specified.

func (RandomFunction) Name 

func (fn RandomFunction) Name() string

Name represents the JSON field name under which the output of Source needs to be serialized by FunctionScoreQuery (see FunctionScoreQuery.Source).

func (RandomFunction) Seed 

func (fn RandomFunction) Seed(seed interface{}) RandomFunction

Seed is documented in 1.6 as a numeric value. However, in the source code of the Java client, it also accepts strings. So we accept both here, too.

func (RandomFunction) Source 

func (fn RandomFunction) Source() interface{}

Source returns the serializable JSON data of this score function.

func (RandomFunction) Weight 

func (fn RandomFunction) Weight(weight float64) RandomFunction

Weight adjusts the score of the score function. See https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-function-score-query.html#_using_function_score for details.

type RangeAggregation 

type RangeAggregation struct {
	// contains filtered or unexported fields
}

RangeAggregation is a multi-bucket value source based aggregation that enables the user to define a set of ranges - each representing a bucket. During the aggregation process, the values extracted from each document will be checked against each bucket range and "bucket" the relevant/matching document. Note that this aggregration includes the from value and excludes the to value for each range. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-range-aggregation.html

func NewRangeAggregation 

func NewRangeAggregation() RangeAggregation

func (RangeAggregation) AddRange 

func (a RangeAggregation) AddRange(from, to interface{}) RangeAggregation

func (RangeAggregation) AddRangeWithKey 

func (a RangeAggregation) AddRangeWithKey(key string, from, to interface{}) RangeAggregation

func (RangeAggregation) AddUnboundedFrom 

func (a RangeAggregation) AddUnboundedFrom(to interface{}) RangeAggregation

func (RangeAggregation) AddUnboundedFromWithKey 

func (a RangeAggregation) AddUnboundedFromWithKey(key string, to interface{}) RangeAggregation

func (RangeAggregation) AddUnboundedTo 

func (a RangeAggregation) AddUnboundedTo(from interface{}) RangeAggregation

func (RangeAggregation) AddUnboundedToWithKey 

func (a RangeAggregation) AddUnboundedToWithKey(key string, from interface{}) RangeAggregation

func (RangeAggregation) Between 

func (a RangeAggregation) Between(from, to interface{}) RangeAggregation

func (RangeAggregation) BetweenWithKey 

func (a RangeAggregation) BetweenWithKey(key string, from, to interface{}) RangeAggregation

func (RangeAggregation) Field 

func (a RangeAggregation) Field(field string) RangeAggregation

func (RangeAggregation) Gt 

func (a RangeAggregation) Gt(from interface{}) RangeAggregation

func (RangeAggregation) GtWithKey 

func (a RangeAggregation) GtWithKey(key string, from interface{}) RangeAggregation

func (RangeAggregation) Keyed 

func (a RangeAggregation) Keyed(keyed bool) RangeAggregation

func (RangeAggregation) Lang 

func (a RangeAggregation) Lang(lang string) RangeAggregation

func (RangeAggregation) Lt 

func (a RangeAggregation) Lt(to interface{}) RangeAggregation

func (RangeAggregation) LtWithKey 

func (a RangeAggregation) LtWithKey(key string, to interface{}) RangeAggregation

func (RangeAggregation) Param 

func (a RangeAggregation) Param(name string, value interface{}) RangeAggregation

func (RangeAggregation) Script 

func (a RangeAggregation) Script(script string) RangeAggregation

func (RangeAggregation) ScriptFile 

func (a RangeAggregation) ScriptFile(scriptFile string) RangeAggregation

func (RangeAggregation) Source 

func (a RangeAggregation) Source() interface{}

func (RangeAggregation) SubAggregation 

func (a RangeAggregation) SubAggregation(name string, subAggregation Aggregation) RangeAggregation

func (RangeAggregation) Unmapped 

func (a RangeAggregation) Unmapped(unmapped bool) RangeAggregation

type RangeFacet 

type RangeFacet struct {
	// contains filtered or unexported fields
}

Range facet allows to specify a set of ranges and get both the number of docs (count) that fall within each range, and aggregated data either based on the field, or using another field. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-facets-range-facet.html

func NewRangeFacet 

func NewRangeFacet() RangeFacet

func (RangeFacet) AddRange 

func (f RangeFacet) AddRange(from, to interface{}) RangeFacet

func (RangeFacet) AddUnboundedFrom 

func (f RangeFacet) AddUnboundedFrom(to interface{}) RangeFacet

func (RangeFacet) AddUnboundedTo 

func (f RangeFacet) AddUnboundedTo(from interface{}) RangeFacet

func (RangeFacet) Between 

func (f RangeFacet) Between(from, to interface{}) RangeFacet

func (RangeFacet) FacetFilter 

func (f RangeFacet) FacetFilter(filter Facet) RangeFacet

func (RangeFacet) Field 

func (f RangeFacet) Field(field string) RangeFacet

func (RangeFacet) Global 

func (f RangeFacet) Global(global bool) RangeFacet

func (RangeFacet) Gt 

func (f RangeFacet) Gt(from interface{}) RangeFacet

func (RangeFacet) KeyField 

func (f RangeFacet) KeyField(keyField string) RangeFacet

func (RangeFacet) Lt 

func (f RangeFacet) Lt(to interface{}) RangeFacet

func (RangeFacet) Mode 

func (f RangeFacet) Mode(mode string) RangeFacet

func (RangeFacet) Nested 

func (f RangeFacet) Nested(nested string) RangeFacet

func (RangeFacet) Source 

func (f RangeFacet) Source() interface{}

func (RangeFacet) ValueField 

func (f RangeFacet) ValueField(valueField string) RangeFacet

type RangeFilter 

type RangeFilter struct {
	Filter
	// contains filtered or unexported fields
}

Filters documents with fields that have terms within a certain range. For details, see: http://www.elasticsearch.org/guide/reference/query-dsl/range-filter.html

func NewRangeFilter 

func NewRangeFilter(name string) RangeFilter

func (RangeFilter) Cache 

func (f RangeFilter) Cache(cache bool) RangeFilter

func (RangeFilter) CacheKey 

func (f RangeFilter) CacheKey(cacheKey string) RangeFilter

func (RangeFilter) Execution 

func (f RangeFilter) Execution(execution string) RangeFilter

func (RangeFilter) FilterName 

func (f RangeFilter) FilterName(filterName string) RangeFilter

func (RangeFilter) Format 

func (f RangeFilter) Format(format string) RangeFilter

Format is a valid option for date fields in a Range filter.

func (RangeFilter) From 

func (f RangeFilter) From(from interface{}) RangeFilter

func (RangeFilter) Gt 

func (f RangeFilter) Gt(from interface{}) RangeFilter

func (RangeFilter) Gte 

func (f RangeFilter) Gte(from interface{}) RangeFilter

func (RangeFilter) IncludeLower 

func (f RangeFilter) IncludeLower(includeLower bool) RangeFilter

func (RangeFilter) IncludeUpper 

func (f RangeFilter) IncludeUpper(includeUpper bool) RangeFilter

func (RangeFilter) Lt 

func (f RangeFilter) Lt(to interface{}) RangeFilter

func (RangeFilter) Lte 

func (f RangeFilter) Lte(to interface{}) RangeFilter

func (RangeFilter) Source 

func (f RangeFilter) Source() interface{}

func (RangeFilter) TimeZone 

func (f RangeFilter) TimeZone(timeZone string) RangeFilter

TimeZone allows for adjusting the from/to fields using a time zone. Only valid for date fields.

func (RangeFilter) To 

func (f RangeFilter) To(to interface{}) RangeFilter

type RangeQuery 

type RangeQuery struct {
	Query
	// contains filtered or unexported fields
}

Matches documents with fields that have terms within a certain range. For details, see: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-range-query.html

func NewRangeQuery 

func NewRangeQuery(name string) RangeQuery

func (RangeQuery) Boost 

func (q RangeQuery) Boost(boost float64) RangeQuery

func (RangeQuery) Format 

func (q RangeQuery) Format(format string) RangeQuery

Format is a valid option for date fields in a Range query.

func (RangeQuery) From 

func (q RangeQuery) From(from interface{}) RangeQuery

func (RangeQuery) Gt 

func (q RangeQuery) Gt(from interface{}) RangeQuery

func (RangeQuery) Gte 

func (q RangeQuery) Gte(from interface{}) RangeQuery

func (RangeQuery) IncludeLower 

func (q RangeQuery) IncludeLower(includeLower bool) RangeQuery

func (RangeQuery) IncludeUpper 

func (q RangeQuery) IncludeUpper(includeUpper bool) RangeQuery

func (RangeQuery) Lt 

func (q RangeQuery) Lt(to interface{}) RangeQuery

func (RangeQuery) Lte 

func (q RangeQuery) Lte(to interface{}) RangeQuery

func (RangeQuery) QueryName 

func (q RangeQuery) QueryName(queryName string) RangeQuery

func (RangeQuery) Source 

func (q RangeQuery) Source() interface{}

func (RangeQuery) TimeZone 

func (q RangeQuery) TimeZone(timeZone string) RangeQuery

TimeZone allows for adjusting the from/to fields using a time zone. Only valid for date fields.

func (RangeQuery) To 

func (q RangeQuery) To(to interface{}) RangeQuery

type RefreshResult 

type RefreshResult struct {
	Shards shardsInfo `json:"_shards,omitempty"`
}

type RefreshService 

type RefreshService struct {
	// contains filtered or unexported fields
}

func NewRefreshService 

func NewRefreshService(client *Client) *RefreshService

func (*RefreshService) Do 

func (s *RefreshService) Do() (*RefreshResult, error)

func (*RefreshService) Force 

func (s *RefreshService) Force(force bool) *RefreshService

func (*RefreshService) Index 

func (s *RefreshService) Index(index string) *RefreshService

func (*RefreshService) Indices 

func (s *RefreshService) Indices(indices ...string) *RefreshService

func (*RefreshService) Pretty 

func (s *RefreshService) Pretty(pretty bool) *RefreshService

type RegexpFilter 

type RegexpFilter struct {
	Filter
	// contains filtered or unexported fields
}

RegexpFilter allows filtering for regular expressions. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-regexp-filter.html and http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-regexp-query.html#regexp-syntax for details.

func NewRegexpFilter 

func NewRegexpFilter(name, regexp string) RegexpFilter

NewRegexpFilter sets up a new RegexpFilter.

func (RegexpFilter) Cache 

func (f RegexpFilter) Cache(cache bool) RegexpFilter

func (RegexpFilter) CacheKey 

func (f RegexpFilter) CacheKey(cacheKey string) RegexpFilter

func (RegexpFilter) FilterName 

func (f RegexpFilter) FilterName(filterName string) RegexpFilter

func (RegexpFilter) Flags 

func (f RegexpFilter) Flags(flags string) RegexpFilter

Flags sets the regexp flags. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-regexp-query.html#_optional_operators for details.

func (RegexpFilter) MaxDeterminizedStates 

func (f RegexpFilter) MaxDeterminizedStates(maxDeterminizedStates int) RegexpFilter

func (RegexpFilter) Source 

func (f RegexpFilter) Source() interface{}

type RegexpQuery 

type RegexpQuery struct {
	Query
	// contains filtered or unexported fields
}

RegexpQuery allows you to use regular expression term queries. For more details, see http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-regexp-query.html.

func NewRegexpQuery 

func NewRegexpQuery(name string, regexp string) RegexpQuery

NewRegexpQuery creates a new regexp query.

func (RegexpQuery) Boost 

func (q RegexpQuery) Boost(boost float64) RegexpQuery

func (RegexpQuery) Flags 

func (q RegexpQuery) Flags(flags string) RegexpQuery

Flags sets the regexp flags. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-regexp-query.html#_optional_operators for details.

func (RegexpQuery) MaxDeterminizedStates 

func (q RegexpQuery) MaxDeterminizedStates(maxDeterminizedStates int) RegexpQuery

func (RegexpQuery) QueryName 

func (q RegexpQuery) QueryName(queryName string) RegexpQuery

func (RegexpQuery) Rewrite 

func (q RegexpQuery) Rewrite(rewrite string) RegexpQuery

func (RegexpQuery) Source 

func (q RegexpQuery) Source() interface{}

Source returns the JSON-serializable query data.

type Reindexer 

type Reindexer struct {
	// contains filtered or unexported fields
}

Reindexer simplifies the process of reindexing an index. You typically reindex a source index to a target index. However, you can also specify a query that filters out documents from the source index before bulk indexing them into the target index. The caller may also specify a different client for the target, e.g. when copying indices from one Elasticsearch cluster to another.

Internally, the Reindex users a scan and scroll operation on the source index and bulk indexing to push data into the target index.

By default the reindexer fetches the _source, _parent, and _routing attributes from the source index, using the provided CopyToTargetIndex will copy those attributes into the destinationIndex. This behaviour can be overridden by setting the ScanFields and providing a custom ReindexerFunc.

The caller is responsible for setting up and/or clearing the target index before starting the reindex process.

See http://www.elastic.co/guide/en/elasticsearch/guide/current/reindex.html for more information about reindexing.

func NewReindexer 

func NewReindexer(client *Client, source string, reindexerFunc ReindexerFunc) *Reindexer

NewReindexer returns a new Reindexer.

func (*Reindexer) BulkSize 

func (ix *Reindexer) BulkSize(bulkSize int) *Reindexer

BulkSize returns the number of documents to send to Elasticsearch per chunk. The default is 500.

func (*Reindexer) Do 

func (ix *Reindexer) Do() (*ReindexerResponse, error)

Do starts the reindexing process.

func (*Reindexer) Progress 

func (ix *Reindexer) Progress(f ReindexerProgressFunc) *Reindexer

Progress indicates a callback that will be called while indexing.

func (*Reindexer) Query 

func (ix *Reindexer) Query(q Query) *Reindexer

Query specifies the query to apply to the source. It filters out those documents to be indexed into target. A nil query does not filter out any documents.

func (*Reindexer) ScanFields 

func (ix *Reindexer) ScanFields(scanFields ...string) *Reindexer

ScanFields specifies the fields the scan query should load. The default fields are _source, _parent, _routing.

func (*Reindexer) Scroll 

func (ix *Reindexer) Scroll(timeout string) *Reindexer

Scroll specifies for how long the scroll operation on the source index should be maintained. The default is 5m.

func (*Reindexer) Size 

func (ix *Reindexer) Size(size int) *Reindexer

Size is the number of results to return per shard, not per request. So a size of 10 which hits 5 shards will return a maximum of 50 results per scan request.

func (*Reindexer) StatsOnly 

func (ix *Reindexer) StatsOnly(statsOnly bool) *Reindexer

StatsOnly indicates whether the Do method should return details e.g. about the documents that failed while indexing. It is true by default, i.e. only the number of documents that succeeded/failed are returned. Set to false if you want all the details.

func (*Reindexer) TargetClient 

func (ix *Reindexer) TargetClient(c *Client) *Reindexer

TargetClient specifies a different client for the target. This is necessary when the target index is in a different Elasticsearch cluster. By default, the source and target clients are the same.

type ReindexerFunc 

type ReindexerFunc func(hit *SearchHit, bulkService *BulkService) error

A ReindexerFunc receives each hit from the sourceIndex. It can choose to add any number of BulkableRequests to the bulkService.

func CopyToTargetIndex 

func CopyToTargetIndex(targetIndex string) ReindexerFunc

CopyToTargetIndex returns a ReindexerFunc that copies the SearchHit's _source, _parent, and _routing attributes into the targetIndex

type ReindexerProgressFunc 

type ReindexerProgressFunc func(current, total int64)

ReindexerProgressFunc is a callback that can be used with Reindexer to report progress while reindexing data.

type ReindexerResponse 

type ReindexerResponse struct {
	Success int64
	Failed  int64
	Errors  []*BulkResponseItem
}

ReindexerResponse is returned from the Do func in a Reindexer. By default, it returns the number of succeeded and failed bulk operations. To return details about all failed items, set StatsOnly to false in Reindexer.

type Request 

type Request http.Request

Elasticsearch-specific HTTP request

func NewRequest 

func NewRequest(method, url string) (*Request, error)

NewRequest is a http.Request and adds features such as encoding the body.

func (*Request) SetBasicAuth 

func (r *Request) SetBasicAuth(username, password string)

SetBasicAuth wraps http.Request's SetBasicAuth.

func (*Request) SetBody 

func (r *Request) SetBody(body interface{}, gzipCompress bool) error

SetBody encodes the body in the request. Optionally, it performs GZIP compression.

type Rescore 

type Rescore struct {
	// contains filtered or unexported fields
}

func NewRescore 

func NewRescore() *Rescore

func (*Rescore) IsEmpty 

func (r *Rescore) IsEmpty() bool

func (*Rescore) Rescorer 

func (r *Rescore) Rescorer(rescorer Rescorer) *Rescore

func (*Rescore) Source 

func (r *Rescore) Source() interface{}

func (*Rescore) WindowSize 

func (r *Rescore) WindowSize(windowSize int) *Rescore

type Rescorer 

type Rescorer interface {
	Name() string
	Source() interface{}
}

type Response 

type Response struct {
	// StatusCode is the HTTP status code, e.g. 200.
	StatusCode int
	// Header is the HTTP header from the HTTP response.
	// Keys in the map are canonicalized (see http.CanonicalHeaderKey).
	Header http.Header
	// Body is the deserialized response body.
	Body json.RawMessage
}

Response represents a response from Elasticsearch.

type ScanCursor 

type ScanCursor struct {
	Results *SearchResult
	// contains filtered or unexported fields
}

scanCursor represents a single page of results from an Elasticsearch Scan operation.

func NewScanCursor 

func NewScanCursor(client *Client, keepAlive string, pretty bool, searchResult *SearchResult) *ScanCursor

newScanCursor returns a new initialized instance of scanCursor.

func (*ScanCursor) Next 

func (c *ScanCursor) Next() (*SearchResult, error)

Next returns the next search result or nil when all documents have been scanned.

Usage: 

for {
  res, err := cursor.Next()
  if err == elastic.EOS {
    // End of stream (or scan)
    break
  }
  if err != nil {
    // Handle error
  }
  // Work with res
}

func (*ScanCursor) TotalHits 

func (c *ScanCursor) TotalHits() int64

TotalHits is a convenience method that returns the number of hits the cursor will iterate through.

type ScanService 

type ScanService struct {
	// contains filtered or unexported fields
}

ScanService manages a cursor through documents in Elasticsearch.

func NewScanService 

func NewScanService(client *Client) *ScanService

NewScanService creates a new service to iterate through the results of a query.

func (*ScanService) Do 

func (s *ScanService) Do() (*ScanCursor, error)

Do executes the query and returns a "server-side cursor".

func (*ScanService) FetchSource 

func (s *ScanService) FetchSource(fetchSource bool) *ScanService

FetchSource indicates whether the response should contain the stored _source for every hit.

func (*ScanService) FetchSourceContext 

func (s *ScanService) FetchSourceContext(fetchSourceContext *FetchSourceContext) *ScanService

FetchSourceContext indicates how the _source should be fetched.

func (*ScanService) Fields 

func (s *ScanService) Fields(fields ...string) *ScanService

Fields tells Elasticsearch to only load specific fields from a search hit. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-fields.html.

func (*ScanService) Index 

func (s *ScanService) Index(index string) *ScanService

Index sets the name of the index to use for scan.

func (*ScanService) Indices 

func (s *ScanService) Indices(indices ...string) *ScanService

Indices sets the names of the indices to use for scan.

func (*ScanService) KeepAlive 

func (s *ScanService) KeepAlive(keepAlive string) *ScanService

KeepAlive sets the maximum time the cursor will be available before expiration (e.g. "5m" for 5 minutes).

func (*ScanService) PostFilter 

func (s *ScanService) PostFilter(postFilter Filter) *ScanService

PostFilter is executed as the last filter. It only affects the search hits but not facets. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-post-filter.html for details.

func (*ScanService) Preference 

func (s *ScanService) Preference(preference string) *ScanService

Preference specifies the node or shard the operation should be performed on (default: "random").

func (*ScanService) Pretty 

func (s *ScanService) Pretty(pretty bool) *ScanService

Pretty enables the caller to indent the JSON output.

func (*ScanService) Query 

func (s *ScanService) Query(query Query) *ScanService

Query sets the query to perform, e.g. MatchAllQuery.

func (*ScanService) Routing 

func (s *ScanService) Routing(routings ...string) *ScanService

Routing allows for (a comma-separated) list of specific routing values.

func (*ScanService) Scroll 

func (s *ScanService) Scroll(keepAlive string) *ScanService

Scroll is an alias for KeepAlive, the time to keep the cursor alive (e.g. "5m" for 5 minutes).

func (*ScanService) SearchSource 

func (s *ScanService) SearchSource(searchSource *SearchSource) *ScanService

SearchSource sets the search source builder to use with this service.

func (*ScanService) Size 

func (s *ScanService) Size(size int) *ScanService

Size is the number of results to return per shard, not per request. So a size of 10 which hits 5 shards will return a maximum of 50 results per scan request.

func (*ScanService) Sort 

func (s *ScanService) Sort(field string, ascending bool) *ScanService

Sort the results by the given field, in the given order. Use the alternative SortWithInfo to use a struct to define the sorting. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-sort.html for detailed documentation of sorting.

func (*ScanService) SortBy 

func (s *ScanService) SortBy(sorter ...Sorter) *ScanService

SortBy defines how to sort results. Use the Sort func for a shortcut. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-sort.html for detailed documentation of sorting.

func (*ScanService) SortWithInfo 

func (s *ScanService) SortWithInfo(info SortInfo) *ScanService

SortWithInfo defines how to sort results. Use the Sort func for a shortcut. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-sort.html for detailed documentation of sorting.

func (*ScanService) Type 

func (s *ScanService) Type(typ string) *ScanService

Type restricts the scan to the given type.

func (*ScanService) Types 

func (s *ScanService) Types(types ...string) *ScanService

Types allows to restrict the scan to a list of types.

func (*ScanService) Version 

func (s *ScanService) Version(version bool) *ScanService

Version can be set to true to return a version for each search hit. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-version.html.

type ScoreFunction 

type ScoreFunction interface {
	Name() string
	GetWeight() *float64 // returns the weight which must be serialized at the level of FunctionScoreQuery
	Source() interface{}
}

ScoreFunction is used in combination with the Function Score Query.

type ScoreSort 

type ScoreSort struct {
	Sorter
	// contains filtered or unexported fields
}

ScoreSort sorts by relevancy score.

func NewScoreSort 

func NewScoreSort() ScoreSort

NewScoreSort creates a new ScoreSort.

func (ScoreSort) Asc 

func (s ScoreSort) Asc() ScoreSort

Asc sets ascending sort order.

func (ScoreSort) Desc 

func (s ScoreSort) Desc() ScoreSort

Desc sets descending sort order.

func (ScoreSort) Order 

func (s ScoreSort) Order(ascending bool) ScoreSort

Order defines whether sorting ascending (default) or descending.

func (ScoreSort) Source 

func (s ScoreSort) Source() interface{}

Source returns the JSON-serializable data.

type ScriptField 

type ScriptField struct {
	FieldName string
	// contains filtered or unexported fields
}

func NewScriptField 

func NewScriptField(fieldName, script, lang string, params map[string]interface{}) *ScriptField

func (*ScriptField) Source 

func (f *ScriptField) Source() interface{}

type ScriptFunction 

type ScriptFunction struct {
	// contains filtered or unexported fields
}

ScriptFunction builds a script score function. It uses a script to compute or influence the score of documents that match with the inner query or filter.

See https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-function-score-query.html#_script_score for details.

func NewScriptFunction 

func NewScriptFunction(script string) ScriptFunction

NewScriptFunction initializes and returns a new ScriptFunction.

func (ScriptFunction) GetWeight 

func (fn ScriptFunction) GetWeight() *float64

GetWeight returns the adjusted score. It is part of the ScoreFunction interface. Returns nil if weight is not specified.

func (ScriptFunction) Lang 

func (fn ScriptFunction) Lang(lang string) ScriptFunction

Lang specifies the language of the Script.

func (ScriptFunction) Name 

func (fn ScriptFunction) Name() string

Name represents the JSON field name under which the output of Source needs to be serialized by FunctionScoreQuery (see FunctionScoreQuery.Source).

func (ScriptFunction) Param 

func (fn ScriptFunction) Param(name string, value interface{}) ScriptFunction

Param adds a single parameter to the script.

func (ScriptFunction) Params 

func (fn ScriptFunction) Params(params map[string]interface{}) ScriptFunction

Params sets all script parameters in a single step.

func (ScriptFunction) Script 

func (fn ScriptFunction) Script(script string) ScriptFunction

Script specifies the script to be executed.

func (ScriptFunction) Source 

func (fn ScriptFunction) Source() interface{}

Source returns the serializable JSON data of this score function.

func (ScriptFunction) Weight 

func (fn ScriptFunction) Weight(weight float64) ScriptFunction

Weight adjusts the score of the score function. See https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-function-score-query.html#_using_function_score for details.

type ScriptSort 

type ScriptSort struct {
	Sorter
	// contains filtered or unexported fields
}

ScriptSort sorts by a custom script. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/modules-scripting.html#modules-scripting for details about scripting.

func NewScriptSort 

func NewScriptSort(script, typ string) ScriptSort

NewScriptSort creates a new ScriptSort.

func (ScriptSort) Asc 

func (s ScriptSort) Asc() ScriptSort

Asc sets ascending sort order.

func (ScriptSort) Desc 

func (s ScriptSort) Desc() ScriptSort

Desc sets descending sort order.

func (ScriptSort) Lang 

func (s ScriptSort) Lang(lang string) ScriptSort

Lang specifies the script language to use. It can be one of: groovy (the default for ES >= 1.4), mvel (default for ES < 1.4), js, python, expression, or native. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/modules-scripting.html#modules-scripting for details.

func (ScriptSort) NestedFilter 

func (s ScriptSort) NestedFilter(nestedFilter Filter) ScriptSort

NestedFilter sets a filter that nested objects should match with in order to be taken into account for sorting.

func (ScriptSort) NestedPath 

func (s ScriptSort) NestedPath(nestedPath string) ScriptSort

NestedPath is used if sorting occurs on a field that is inside a nested object.

func (ScriptSort) Order 

func (s ScriptSort) Order(ascending bool) ScriptSort

Order defines whether sorting ascending (default) or descending.

func (ScriptSort) Param 

func (s ScriptSort) Param(name string, value interface{}) ScriptSort

Param adds a parameter to the script.

func (ScriptSort) Params 

func (s ScriptSort) Params(params map[string]interface{}) ScriptSort

Params sets the parameters of the script.

func (ScriptSort) SortMode 

func (s ScriptSort) SortMode(sortMode string) ScriptSort

SortMode specifies what values to pick in case a document contains multiple values for the targeted sort field. Possible values are: min or max.

func (ScriptSort) Source 

func (s ScriptSort) Source() interface{}

Source returns the JSON-serializable data.

func (ScriptSort) Type 

func (s ScriptSort) Type(typ string) ScriptSort

Type sets the script type, which can be either string or number.

type ScrollService 

type ScrollService struct {
	// contains filtered or unexported fields
}

ScrollService manages a cursor through documents in Elasticsearch.

func NewScrollService 

func NewScrollService(client *Client) *ScrollService

func (*ScrollService) Do 

func (s *ScrollService) Do() (*SearchResult, error)

func (*ScrollService) GetFirstPage 

func (s *ScrollService) GetFirstPage() (*SearchResult, error)

func (*ScrollService) GetNextPage 

func (s *ScrollService) GetNextPage() (*SearchResult, error)

func (*ScrollService) Index 

func (s *ScrollService) Index(index string) *ScrollService

func (*ScrollService) Indices 

func (s *ScrollService) Indices(indices ...string) *ScrollService

func (*ScrollService) KeepAlive 

func (s *ScrollService) KeepAlive(keepAlive string) *ScrollService

KeepAlive sets the maximum time the cursor will be available before expiration (e.g. "5m" for 5 minutes).

func (*ScrollService) Pretty 

func (s *ScrollService) Pretty(pretty bool) *ScrollService

func (*ScrollService) Query 

func (s *ScrollService) Query(query Query) *ScrollService

func (*ScrollService) Scroll 

func (s *ScrollService) Scroll(keepAlive string) *ScrollService

Scroll is an alias for KeepAlive, the time to keep the cursor alive (e.g. "5m" for 5 minutes).

func (*ScrollService) ScrollId 

func (s *ScrollService) ScrollId(scrollId string) *ScrollService

func (*ScrollService) Size 

func (s *ScrollService) Size(size int) *ScrollService

func (*ScrollService) Type 

func (s *ScrollService) Type(typ string) *ScrollService

func (*ScrollService) Types 

func (s *ScrollService) Types(types ...string) *ScrollService

type SearchExplanation 

type SearchExplanation struct {
	Value       float64             `json:"value"`             // e.g. 1.0
	Description string              `json:"description"`       // e.g. "boost" or "ConstantScore(*:*), product of:"
	Details     []SearchExplanation `json:"details,omitempty"` // recursive details
}

SearchExplanation explains how the score for a hit was computed. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-explain.html.

type SearchFacet 

type SearchFacet struct {
	Type    string             `json:"_type"`
	Missing int                `json:"missing"`
	Total   int                `json:"total"`
	Other   int                `json:"other"`
	Terms   []searchFacetTerm  `json:"terms"`
	Ranges  []searchFacetRange `json:"ranges"`
	Entries []searchFacetEntry `json:"entries"`
}

SearchFacet is a single facet. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-facets.html.

type SearchFacets 

type SearchFacets map[string]*SearchFacet

SearchFacets is a map of facets. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-facets.html.

type SearchHit 

type SearchHit struct {
	Score          *float64                       `json:"_score"`          // computed score
	Index          string                         `json:"_index"`          // index name
	Id             string                         `json:"_id"`             // external or internal
	Type           string                         `json:"_type"`           // type
	Version        *int64                         `json:"_version"`        // version number, when Version is set to true in SearchService
	Sort           []interface{}                  `json:"sort"`            // sort information
	Highlight      SearchHitHighlight             `json:"highlight"`       // highlighter information
	Source         *json.RawMessage               `json:"_source"`         // stored document source
	Fields         map[string]interface{}         `json:"fields"`          // returned fields
	Explanation    *SearchExplanation             `json:"_explanation"`    // explains how the score was computed
	MatchedQueries []string                       `json:"matched_queries"` // matched queries
	InnerHits      map[string]*SearchHitInnerHits `json:"inner_hits"`      // inner hits with ES >= 1.5.0

}

SearchHit is a single hit.

type SearchHitHighlight 

type SearchHitHighlight map[string][]string

SearchHitHighlight is the highlight information of a search hit. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-highlighting.html for a general discussion of highlighting.

type SearchHitInnerHits 

type SearchHitInnerHits struct {
	Hits *SearchHits `json:"hits"`
}

type SearchHits 

type SearchHits struct {
	TotalHits int64        `json:"total"`     // total number of hits found
	MaxScore  *float64     `json:"max_score"` // maximum score of all hits
	Hits      []*SearchHit `json:"hits"`      // the actual hits returned
}

SearchHits specifies the list of search hits.

type SearchRequest 

type SearchRequest struct {
	// contains filtered or unexported fields
}

SearchRequest combines a search request and its query details (see SearchSource). It is used in combination with MultiSearch.

func NewSearchRequest 

func NewSearchRequest() *SearchRequest

NewSearchRequest creates a new search request.

func (*SearchRequest) HasIndices 

func (r *SearchRequest) HasIndices() bool

func (*SearchRequest) Index 

func (r *SearchRequest) Index(index string) *SearchRequest

func (*SearchRequest) Indices 

func (r *SearchRequest) Indices(indices ...string) *SearchRequest

func (*SearchRequest) Preference 

func (r *SearchRequest) Preference(preference string) *SearchRequest

func (*SearchRequest) Routing 

func (r *SearchRequest) Routing(routing string) *SearchRequest

func (*SearchRequest) Routings 

func (r *SearchRequest) Routings(routings ...string) *SearchRequest

func (*SearchRequest) SearchType 

func (r *SearchRequest) SearchType(searchType string) *SearchRequest

SearchRequest must be one of "query_then_fetch", "query_and_fetch", "scan", "count", "dfs_query_then_fetch", or "dfs_query_and_fetch". Use one of the constants defined via SearchType.

func (*SearchRequest) SearchTypeCount 

func (r *SearchRequest) SearchTypeCount() *SearchRequest

func (*SearchRequest) SearchTypeDfsQueryAndFetch 

func (r *SearchRequest) SearchTypeDfsQueryAndFetch() *SearchRequest

func (*SearchRequest) SearchTypeDfsQueryThenFetch 

func (r *SearchRequest) SearchTypeDfsQueryThenFetch() *SearchRequest

func (*SearchRequest) SearchTypeQueryAndFetch 

func (r *SearchRequest) SearchTypeQueryAndFetch() *SearchRequest

func (*SearchRequest) SearchTypeQueryThenFetch 

func (r *SearchRequest) SearchTypeQueryThenFetch() *SearchRequest

func (*SearchRequest) SearchTypeScan 

func (r *SearchRequest) SearchTypeScan() *SearchRequest

func (*SearchRequest) Source 

func (r *SearchRequest) Source(source interface{}) *SearchRequest

func (*SearchRequest) Type 

func (r *SearchRequest) Type(typ string) *SearchRequest

func (*SearchRequest) Types 

func (r *SearchRequest) Types(types ...string) *SearchRequest

type SearchResult 

type SearchResult struct {
	TookInMillis int64         `json:"took"`            // search time in milliseconds
	ScrollId     string        `json:"_scroll_id"`      // only used with Scroll and Scan operations
	Hits         *SearchHits   `json:"hits"`            // the actual search hits
	Suggest      SearchSuggest `json:"suggest"`         // results from suggesters
	Facets       SearchFacets  `json:"facets"`          // results from facets
	Aggregations Aggregations  `json:"aggregations"`    // results from aggregations
	TimedOut     bool          `json:"timed_out"`       // true if the search timed out
	Error        string        `json:"error,omitempty"` // used in MultiSearch only
}

SearchResult is the result of a search in Elasticsearch.

Example 
package main

import (
	"encoding/json"
	"fmt"
	"reflect"
	"time"

	elastic "gopkg.in/olivere/elastic.v2"
)

type Tweet struct {
	User     string                `json:"user"`
	Message  string                `json:"message"`
	Retweets int                   `json:"retweets"`
	Image    string                `json:"image,omitempty"`
	Created  time.Time             `json:"created,omitempty"`
	Tags     []string              `json:"tags,omitempty"`
	Location string                `json:"location,omitempty"`
	Suggest  *elastic.SuggestField `json:"suggest_field,omitempty"`
}

func main() {
	client, err := elastic.NewClient()
	if err != nil {
		panic(err)
	}

	// Do a search
	searchResult, err := client.Search().Index("twitter").Query(elastic.NewMatchAllQuery()).Do()
	if err != nil {
		panic(err)
	}

	// searchResult is of type SearchResult and returns hits, suggestions,
	// and all kinds of other information from Elasticsearch.
	fmt.Printf("Query took %d milliseconds\n", searchResult.TookInMillis)

	// Each is a utility function that iterates over hits in a search result.
	// It makes sure you don't need to check for nil values in the response.
	// However, it ignores errors in serialization. If you want full control
	// over iterating the hits, see below.
	var ttyp Tweet
	for _, item := range searchResult.Each(reflect.TypeOf(ttyp)) {
		t := item.(Tweet)
		fmt.Printf("Tweet by %s: %s\n", t.User, t.Message)
	}
	fmt.Printf("Found a total of %d tweets\n", searchResult.TotalHits())

	// Here's how you iterate hits with full control.
	if searchResult.Hits != nil {
		fmt.Printf("Found a total of %d tweets\n", searchResult.Hits.TotalHits)

		// Iterate through results
		for _, hit := range searchResult.Hits.Hits {
			// hit.Index contains the name of the index

			// Deserialize hit.Source into a Tweet (could also be just a map[string]interface{}).
			var t Tweet
			err := json.Unmarshal(*hit.Source, &t)
			if err != nil {
				// Deserialization failed
			}

			// Work with tweet
			fmt.Printf("Tweet by %s: %s\n", t.User, t.Message)
		}
	} else {
		// No hits
		fmt.Print("Found no tweets\n")
	}
}

Output:

func (*SearchResult) Each 

func (r *SearchResult) Each(typ reflect.Type) []interface{}

Each is a utility function to iterate over all hits. It saves you from checking for nil values. Notice that Each will ignore errors in serializing JSON.

func (*SearchResult) TotalHits 

func (r *SearchResult) TotalHits() int64

TotalHits is a convenience function to return the number of hits for a search result.

type SearchService 

type SearchService struct {
	// contains filtered or unexported fields
}

Search for documents in Elasticsearch.

Example 
package main

import (
	"encoding/json"
	"fmt"
	"time"

	elastic "gopkg.in/olivere/elastic.v2"
)

type Tweet struct {
	User     string                `json:"user"`
	Message  string                `json:"message"`
	Retweets int                   `json:"retweets"`
	Image    string                `json:"image,omitempty"`
	Created  time.Time             `json:"created,omitempty"`
	Tags     []string              `json:"tags,omitempty"`
	Location string                `json:"location,omitempty"`
	Suggest  *elastic.SuggestField `json:"suggest_field,omitempty"`
}

func main() {
	// Get a client to the local Elasticsearch instance.
	client, err := elastic.NewClient()
	if err != nil {
		// Handle error
		panic(err)
	}

	// Search with a term query
	termQuery := elastic.NewTermQuery("user", "olivere")
	searchResult, err := client.Search().
		Index("twitter").   // search in index "twitter"
		Query(&termQuery).  // specify the query
		Sort("user", true). // sort by "user" field, ascending
		From(0).Size(10).   // take documents 0-9
		Pretty(true).       // pretty print request and response JSON
		Do()                // execute
	if err != nil {
		// Handle error
		panic(err)
	}

	// searchResult is of type SearchResult and returns hits, suggestions,
	// and all kinds of other information from Elasticsearch.
	fmt.Printf("Query took %d milliseconds\n", searchResult.TookInMillis)

	// Number of hits
	if searchResult.Hits != nil {
		fmt.Printf("Found a total of %d tweets\n", searchResult.Hits.TotalHits)

		// Iterate through results
		for _, hit := range searchResult.Hits.Hits {
			// hit.Index contains the name of the index

			// Deserialize hit.Source into a Tweet (could also be just a map[string]interface{}).
			var t Tweet
			err := json.Unmarshal(*hit.Source, &t)
			if err != nil {
				// Deserialization failed
			}

			// Work with tweet
			fmt.Printf("Tweet by %s: %s\n", t.User, t.Message)
		}
	} else {
		// No hits
		fmt.Print("Found no tweets\n")
	}
}

Output:

func NewSearchService 

func NewSearchService(client *Client) *SearchService

NewSearchService creates a new service for searching in Elasticsearch. You typically do not create the service yourself manually, but access it via client.Search().

func (*SearchService) Aggregation 

func (s *SearchService) Aggregation(name string, aggregation Aggregation) *SearchService

Aggregation adds an aggregation to the search. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations.html for an overview of aggregations in Elasticsearch.

func (*SearchService) Do 

func (s *SearchService) Do() (*SearchResult, error)

Do executes the search and returns a SearchResult.

func (*SearchService) Explain 

func (s *SearchService) Explain(explain bool) *SearchService

Explain can be enabled to provide an explanation for each hit and how its score was computed. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-explain.html for details.

func (*SearchService) Facet 

func (s *SearchService) Facet(name string, facet Facet) *SearchService

Facet adds a facet to the search. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-facets.html to get an overview of Elasticsearch facets.

func (*SearchService) FetchSource 

func (s *SearchService) FetchSource(fetchSource bool) *SearchService

FetchSource indicates whether the response should contain the stored _source for every hit.

func (*SearchService) FetchSourceContext 

func (s *SearchService) FetchSourceContext(fetchSourceContext *FetchSourceContext) *SearchService

FetchSourceContext indicates how the _source should be fetched.

func (*SearchService) Fields 

func (s *SearchService) Fields(fields ...string) *SearchService

Fields tells Elasticsearch to only load specific fields from a search hit. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-fields.html.

func (*SearchService) From 

func (s *SearchService) From(from int) *SearchService

From defines the offset from the first result you want to fetch. Use it in combination with Size to paginate through results. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-from-size.html for details.

func (*SearchService) GlobalSuggestText 

func (s *SearchService) GlobalSuggestText(globalText string) *SearchService

GlobalSuggestText sets the global text for suggesters. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-suggesters.html#global-suggest for details.

func (*SearchService) Highlight 

func (s *SearchService) Highlight(highlight *Highlight) *SearchService

Highlight sets the highlighting. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-highlighting.html for details.

func (*SearchService) Index 

func (s *SearchService) Index(index string) *SearchService

Index sets the name of the index to use for search.

func (*SearchService) Indices 

func (s *SearchService) Indices(indices ...string) *SearchService

Indices sets the names of the indices to use for search.

func (*SearchService) MinScore 

func (s *SearchService) MinScore(minScore float64) *SearchService

MinScore excludes documents which have a score less than the minimum specified here. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-min-score.html.

func (*SearchService) PostFilter 

func (s *SearchService) PostFilter(postFilter Filter) *SearchService

PostFilter is executed as the last filter. It only affects the search hits but not facets. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-post-filter.html for details.

func (*SearchService) Preference 

func (s *SearchService) Preference(preference string) *SearchService

Preference specifies the node or shard the operation should be performed on (default: "random").

func (*SearchService) Pretty 

func (s *SearchService) Pretty(pretty bool) *SearchService

Pretty enables the caller to indent the JSON output.

func (*SearchService) Query 

func (s *SearchService) Query(query Query) *SearchService

Query sets the query to perform, e.g. MatchAllQuery.

func (*SearchService) QueryHint 

func (s *SearchService) QueryHint(queryHint string) *SearchService

func (*SearchService) Routing 

func (s *SearchService) Routing(routings ...string) *SearchService

Routing allows for (a comma-separated) list of specific routing values.

func (*SearchService) SearchSource 

func (s *SearchService) SearchSource(searchSource *SearchSource) *SearchService

SearchSource sets the search source builder to use with this service.

func (*SearchService) SearchType 

func (s *SearchService) SearchType(searchType string) *SearchService

SearchType sets the search operation type. Valid values are: "query_then_fetch", "query_and_fetch", "dfs_query_then_fetch", "dfs_query_and_fetch", "count", "scan". See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-search-type.html#search-request-search-type for details.

func (*SearchService) Size 

func (s *SearchService) Size(size int) *SearchService

Size defines the maximum number of hits to be returned. Use it in combination with From to paginate through results. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-from-size.html for details.

func (*SearchService) Sort 

func (s *SearchService) Sort(field string, ascending bool) *SearchService

Sort the results by the given field, in the given order. Use the alternative SortWithInfo to use a struct to define the sorting. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-sort.html for detailed documentation of sorting.

func (*SearchService) SortBy 

func (s *SearchService) SortBy(sorter ...Sorter) *SearchService

SortBy defines how to sort results. Use the Sort func for a shortcut. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-sort.html for detailed documentation of sorting.

func (*SearchService) SortWithInfo 

func (s *SearchService) SortWithInfo(info SortInfo) *SearchService

SortWithInfo defines how to sort results. Use the Sort func for a shortcut. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-sort.html for detailed documentation of sorting.

func (*SearchService) Source 

func (s *SearchService) Source(source interface{}) *SearchService

Source allows the user to set the request body manually without using any of the structs and interfaces in Elastic.

func (*SearchService) Suggester 

func (s *SearchService) Suggester(suggester Suggester) *SearchService

Suggester sets the suggester. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-suggesters.html for details.

func (*SearchService) Timeout 

func (s *SearchService) Timeout(timeout string) *SearchService

Timeout sets the timeout to use, e.g. "1s" or "1000ms".

func (*SearchService) TimeoutInMillis 

func (s *SearchService) TimeoutInMillis(timeoutInMillis int) *SearchService

TimeoutInMillis sets the timeout in milliseconds.

func (*SearchService) Type 

func (s *SearchService) Type(typ string) *SearchService

Type adds a search restriction for the given type.

func (*SearchService) Types 

func (s *SearchService) Types(types ...string) *SearchService

Types adds search restrictions for a list of types.

func (*SearchService) Version 

func (s *SearchService) Version(version bool) *SearchService

Version can be set to true to return a version for each search hit. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-version.html.

type SearchSource 

type SearchSource struct {
	// contains filtered or unexported fields
}

SearchSource enables users to build the search source. It resembles the SearchSourceBuilder in Elasticsearch.

func NewSearchSource 

func NewSearchSource() *SearchSource

NewSearchSource initializes a new SearchSource.

func (*SearchSource) AddRescore 

func (s *SearchSource) AddRescore(rescore *Rescore) *SearchSource

AddRescorer adds a rescorer to the search.

func (*SearchSource) Aggregation 

func (s *SearchSource) Aggregation(name string, aggregation Aggregation) *SearchSource

Aggregation adds an aggreation to perform as part of the search.

func (*SearchSource) ClearRescores 

func (s *SearchSource) ClearRescores() *SearchSource

ClearRescorers removes all rescorers from the search.

func (*SearchSource) DefaultRescoreWindowSize 

func (s *SearchSource) DefaultRescoreWindowSize(defaultRescoreWindowSize int) *SearchSource

DefaultRescoreWindowSize sets the rescore window size for rescores that don't specify their window.

func (*SearchSource) Explain 

func (s *SearchSource) Explain(explain bool) *SearchSource

Explain indicates whether each search hit should be returned with an explanation of the hit (ranking).

func (*SearchSource) Facet 

func (s *SearchSource) Facet(name string, facet Facet) *SearchSource

Facet adds a facet to perform as part of the search.

func (*SearchSource) FetchSource 

func (s *SearchSource) FetchSource(fetchSource bool) *SearchSource

FetchSource indicates whether the response should contain the stored _source for every hit.

func (*SearchSource) FetchSourceContext 

func (s *SearchSource) FetchSourceContext(fetchSourceContext *FetchSourceContext) *SearchSource

FetchSourceContext indicates how the _source should be fetched.

func (*SearchSource) Field 

func (s *SearchSource) Field(fieldName string) *SearchSource

Field adds a single field to load and return (note, must be stored) as part of the search request. If none are specified, the source of the document will be returned.

func (*SearchSource) FieldDataField 

func (s *SearchSource) FieldDataField(fieldDataField string) *SearchSource

FieldDataField adds a single field to load from the field data cache and return as part of the search request.

func (*SearchSource) FieldDataFields 

func (s *SearchSource) FieldDataFields(fieldDataFields ...string) *SearchSource

FieldDataFields adds one or more fields to load from the field data cache and return as part of the search request.

func (*SearchSource) Fields 

func (s *SearchSource) Fields(fieldNames ...string) *SearchSource

Fields sets the fields to load and return as part of the search request. If none are specified, the source of the document will be returned.

func (*SearchSource) From 

func (s *SearchSource) From(from int) *SearchSource

From index to start the search from. Defaults to 0.

func (*SearchSource) GlobalSuggestText 

func (s *SearchSource) GlobalSuggestText(text string) *SearchSource

GlobalSuggestText defines the global text to use with all suggesters. This avoids repetition.

func (*SearchSource) Highlight 

func (s *SearchSource) Highlight(highlight *Highlight) *SearchSource

Highlight adds highlighting to the search.

func (*SearchSource) Highlighter 

func (s *SearchSource) Highlighter() *Highlight

Highlighter returns the highlighter.

func (*SearchSource) IndexBoost 

func (s *SearchSource) IndexBoost(index string, boost float64) *SearchSource

IndexBoost sets the boost that a specific index will receive when the query is executed against it.

func (*SearchSource) InnerHit 

func (s *SearchSource) InnerHit(name string, innerHit *InnerHit) *SearchSource

InnerHit adds an inner hit to return with the result.

func (*SearchSource) MinScore 

func (s *SearchSource) MinScore(minScore float64) *SearchSource

MinScore sets the minimum score below which docs will be filtered out.

func (*SearchSource) NoFields 

func (s *SearchSource) NoFields() *SearchSource

NoFields indicates that no fields should be loaded, resulting in only id and type to be returned per field.

func (*SearchSource) PartialField 

func (s *SearchSource) PartialField(partialField *PartialField) *SearchSource

PartialField adds a partial field.

func (*SearchSource) PartialFields 

func (s *SearchSource) PartialFields(partialFields ...*PartialField) *SearchSource

PartialFields adds partial fields.

func (*SearchSource) PostFilter 

func (s *SearchSource) PostFilter(postFilter Filter) *SearchSource

PostFilter will be executed after the query has been executed and only affects the search hits, not the aggregations. This filter is always executed as the last filtering mechanism.

func (*SearchSource) Query 

func (s *SearchSource) Query(query Query) *SearchSource

Query sets the query to use with this search source.

func (*SearchSource) ScriptField 

func (s *SearchSource) ScriptField(scriptField *ScriptField) *SearchSource

ScriptField adds a single script field with the provided script.

func (*SearchSource) ScriptFields 

func (s *SearchSource) ScriptFields(scriptFields ...*ScriptField) *SearchSource

ScriptFields adds one or more script fields with the provided scripts.

func (*SearchSource) Size 

func (s *SearchSource) Size(size int) *SearchSource

Size is the number of search hits to return. Defaults to 10.

func (*SearchSource) Sort 

func (s *SearchSource) Sort(field string, ascending bool) *SearchSource

Sort adds a sort order.

func (*SearchSource) SortBy 

func (s *SearchSource) SortBy(sorter ...Sorter) *SearchSource

SortBy adds a sort order.

func (*SearchSource) SortWithInfo 

func (s *SearchSource) SortWithInfo(info SortInfo) *SearchSource

SortWithInfo adds a sort order.

func (*SearchSource) Source 

func (s *SearchSource) Source() interface{}

Source returns the serializable JSON for the source builder.

func (*SearchSource) Stats 

func (s *SearchSource) Stats(statsGroup ...string) *SearchSource

Stats group this request will be aggregated under.

func (*SearchSource) Suggester 

func (s *SearchSource) Suggester(suggester Suggester) *SearchSource

Suggester adds a suggester to the search.

func (*SearchSource) Timeout 

func (s *SearchSource) Timeout(timeout string) *SearchSource

Timeout controls how long a search is allowed to take, e.g. "1s" or "500ms".

func (*SearchSource) TimeoutInMillis 

func (s *SearchSource) TimeoutInMillis(timeoutInMillis int) *SearchSource

TimeoutInMillis controls how many milliseconds a search is allowed to take before it is canceled.

func (*SearchSource) TrackScores 

func (s *SearchSource) TrackScores(trackScores bool) *SearchSource

TrackScores is applied when sorting and controls if scores will be tracked as well. Defaults to false.

func (*SearchSource) Version 

func (s *SearchSource) Version(version bool) *SearchSource

Version indicates whether each search hit should be returned with a version associated to it.

type SearchSuggest 

type SearchSuggest map[string][]SearchSuggestion

SearchSuggest is a map of suggestions. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-suggesters.html.

type SearchSuggestion 

type SearchSuggestion struct {
	Text    string                   `json:"text"`
	Offset  int                      `json:"offset"`
	Length  int                      `json:"length"`
	Options []SearchSuggestionOption `json:"options"`
}

SearchSuggestion is a single search suggestion. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-suggesters.html.

type SearchSuggestionOption 

type SearchSuggestionOption struct {
	Text         string      `json:"text"`
	Highlighted  string      `json:"highlighted"`
	Score        float32     `json:"score"`
	CollateMatch bool        `json:"collate_match"`
	Freq         int         `json:"freq"` // deprecated
	Payload      interface{} `json:"payload"`
}

SearchSuggestionOption is an option of a SearchSuggestion. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-suggesters.html.

type SignificantTermsAggregation 

type SignificantTermsAggregation struct {
	// contains filtered or unexported fields
}

SignificantSignificantTermsAggregation is an aggregation that returns interesting or unusual occurrences of terms in a set. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-significantterms-aggregation.html

func NewSignificantTermsAggregation 

func NewSignificantTermsAggregation() SignificantTermsAggregation

func (SignificantTermsAggregation) BackgroundFilter 

func (a SignificantTermsAggregation) BackgroundFilter(filter Filter) SignificantTermsAggregation

func (SignificantTermsAggregation) ExecutionHint 

func (a SignificantTermsAggregation) ExecutionHint(hint string) SignificantTermsAggregation

func (SignificantTermsAggregation) Field 

func (a SignificantTermsAggregation) Field(field string) SignificantTermsAggregation

func (SignificantTermsAggregation) MinDocCount 

func (a SignificantTermsAggregation) MinDocCount(minDocCount int) SignificantTermsAggregation

func (SignificantTermsAggregation) RequiredSize 

func (a SignificantTermsAggregation) RequiredSize(requiredSize int) SignificantTermsAggregation

func (SignificantTermsAggregation) ShardMinDocCount 

func (a SignificantTermsAggregation) ShardMinDocCount(shardMinDocCount int) SignificantTermsAggregation

func (SignificantTermsAggregation) ShardSize 

func (a SignificantTermsAggregation) ShardSize(shardSize int) SignificantTermsAggregation

func (SignificantTermsAggregation) Source 

func (a SignificantTermsAggregation) Source() interface{}

func (SignificantTermsAggregation) SubAggregation 

func (a SignificantTermsAggregation) SubAggregation(name string, subAggregation Aggregation) SignificantTermsAggregation

type SimpleQueryStringQuery 

type SimpleQueryStringQuery struct {
	// contains filtered or unexported fields
}

SimpleQueryStringQuery is a query that uses the SimpleQueryParser to parse its context. Unlike the regular query_string query, the simple_query_string query will never throw an exception, and discards invalid parts of the query. For more details, see http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-simple-query-string-query.html

func NewSimpleQueryStringQuery 

func NewSimpleQueryStringQuery(text string) SimpleQueryStringQuery

Creates a new simple query string query.

func (SimpleQueryStringQuery) Analyzer 

func (q SimpleQueryStringQuery) Analyzer(analyzer string) SimpleQueryStringQuery

func (SimpleQueryStringQuery) DefaultOperator 

func (q SimpleQueryStringQuery) DefaultOperator(defaultOperator string) SimpleQueryStringQuery

func (SimpleQueryStringQuery) Field 

func (q SimpleQueryStringQuery) Field(field string) SimpleQueryStringQuery

func (SimpleQueryStringQuery) FieldWithBoost 

func (q SimpleQueryStringQuery) FieldWithBoost(field string, boost float32) SimpleQueryStringQuery

func (SimpleQueryStringQuery) Source 

func (q SimpleQueryStringQuery) Source() interface{}

Creates the query source for the query string query.

type SmoothingModel 

type SmoothingModel interface {
	Type() string
	Source() interface{}
}

type SortInfo 

type SortInfo struct {
	Sorter
	Field          string
	Ascending      bool
	Missing        interface{}
	IgnoreUnmapped *bool
	SortMode       string
	NestedFilter   Filter
	NestedPath     string
}

SortInfo contains information about sorting a field.

func (SortInfo) Source 

func (info SortInfo) Source() interface{}

type Sorter 

type Sorter interface {
	Source() interface{}
}

Sorter is an interface for sorting strategies, e.g. ScoreSort or FieldSort. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-sort.html.

type StatisticalFacet 

type StatisticalFacet struct {
	// contains filtered or unexported fields
}

Statistical facet allows to compute statistical data on a numeric fields. The statistical data include count, total, sum of squares, mean (average), minimum, maximum, variance, and standard deviation. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-facets-statistical-facet.html

func NewStatisticalFacet 

func NewStatisticalFacet() StatisticalFacet

func (StatisticalFacet) FacetFilter 

func (f StatisticalFacet) FacetFilter(filter Facet) StatisticalFacet

func (StatisticalFacet) Field 

func (f StatisticalFacet) Field(fieldName string) StatisticalFacet

func (StatisticalFacet) Fields 

func (f StatisticalFacet) Fields(fieldNames ...string) StatisticalFacet

func (StatisticalFacet) Global 

func (f StatisticalFacet) Global(global bool) StatisticalFacet

func (StatisticalFacet) Mode 

func (f StatisticalFacet) Mode(mode string) StatisticalFacet

func (StatisticalFacet) Nested 

func (f StatisticalFacet) Nested(nested string) StatisticalFacet

func (StatisticalFacet) Source 

func (f StatisticalFacet) Source() interface{}

type StatisticalScriptFacet 

type StatisticalScriptFacet struct {
	// contains filtered or unexported fields
}

Statistical facet allows to compute statistical data on a numeric fields. The statistical data include count, total, sum of squares, mean (average), minimum, maximum, variance, and standard deviation. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-facets-statistical-facet.html

func NewStatisticalScriptFacet 

func NewStatisticalScriptFacet() StatisticalScriptFacet

func (StatisticalScriptFacet) FacetFilter 

func (f StatisticalScriptFacet) FacetFilter(filter Facet) StatisticalScriptFacet

func (StatisticalScriptFacet) Global 

func (f StatisticalScriptFacet) Global(global bool) StatisticalScriptFacet

func (StatisticalScriptFacet) Lang 

func (f StatisticalScriptFacet) Lang(lang string) StatisticalScriptFacet

func (StatisticalScriptFacet) Mode 

func (f StatisticalScriptFacet) Mode(mode string) StatisticalScriptFacet

func (StatisticalScriptFacet) Nested 

func (f StatisticalScriptFacet) Nested(nested string) StatisticalScriptFacet

func (StatisticalScriptFacet) Param 

func (f StatisticalScriptFacet) Param(name string, value interface{}) StatisticalScriptFacet

func (StatisticalScriptFacet) Script 

func (f StatisticalScriptFacet) Script(script string) StatisticalScriptFacet

func (StatisticalScriptFacet) Source 

func (f StatisticalScriptFacet) Source() interface{}

type StatsAggregation 

type StatsAggregation struct {
	// contains filtered or unexported fields
}

StatsAggregation is a multi-value metrics aggregation that computes stats over numeric values extracted from the aggregated documents. These values can be extracted either from specific numeric fields in the documents, or be generated by a provided script. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-metrics-stats-aggregation.html

func NewStatsAggregation 

func NewStatsAggregation() StatsAggregation

func (StatsAggregation) Field 

func (a StatsAggregation) Field(field string) StatsAggregation

func (StatsAggregation) Format 

func (a StatsAggregation) Format(format string) StatsAggregation

func (StatsAggregation) Lang 

func (a StatsAggregation) Lang(lang string) StatsAggregation

func (StatsAggregation) Param 

func (a StatsAggregation) Param(name string, value interface{}) StatsAggregation

func (StatsAggregation) Script 

func (a StatsAggregation) Script(script string) StatsAggregation

func (StatsAggregation) ScriptFile 

func (a StatsAggregation) ScriptFile(scriptFile string) StatsAggregation

func (StatsAggregation) Source 

func (a StatsAggregation) Source() interface{}

func (StatsAggregation) SubAggregation 

func (a StatsAggregation) SubAggregation(name string, subAggregation Aggregation) StatsAggregation

type StupidBackoffSmoothingModel 

type StupidBackoffSmoothingModel struct {
	// contains filtered or unexported fields
}

StupidBackoffSmoothingModel implements a stupid backoff smoothing model. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-suggesters-phrase.html#_smoothing_models for details about smoothing models.

func NewStupidBackoffSmoothingModel 

func NewStupidBackoffSmoothingModel(discount float64) *StupidBackoffSmoothingModel

func (*StupidBackoffSmoothingModel) Source 

func (sm *StupidBackoffSmoothingModel) Source() interface{}

func (*StupidBackoffSmoothingModel) Type 

func (sm *StupidBackoffSmoothingModel) Type() string

type SuggestField 

type SuggestField struct {
	// contains filtered or unexported fields
}

SuggestField can be used by the caller to specify a suggest field at index time. For a detailed example, see e.g. http://www.elasticsearch.org/blog/you-complete-me/.

func NewSuggestField 

func NewSuggestField() *SuggestField

func (*SuggestField) ContextQuery 

func (f *SuggestField) ContextQuery(queries ...SuggesterContextQuery) *SuggestField

func (*SuggestField) Input 

func (f *SuggestField) Input(input ...string) *SuggestField

func (*SuggestField) MarshalJSON 

func (f *SuggestField) MarshalJSON() ([]byte, error)

MarshalJSON encodes SuggestField into JSON.

func (*SuggestField) Output 

func (f *SuggestField) Output(output string) *SuggestField

func (*SuggestField) Payload 

func (f *SuggestField) Payload(payload interface{}) *SuggestField

func (*SuggestField) Weight 

func (f *SuggestField) Weight(weight int) *SuggestField

type SuggestResult 

type SuggestResult map[string][]Suggestion

type SuggestService 

type SuggestService struct {
	// contains filtered or unexported fields
}

SuggestService returns suggestions for text.

func NewSuggestService 

func NewSuggestService(client *Client) *SuggestService

func (*SuggestService) Do 

func (s *SuggestService) Do() (SuggestResult, error)

func (*SuggestService) Index 

func (s *SuggestService) Index(index string) *SuggestService

func (*SuggestService) Indices 

func (s *SuggestService) Indices(indices ...string) *SuggestService

func (*SuggestService) Preference 

func (s *SuggestService) Preference(preference string) *SuggestService

func (*SuggestService) Pretty 

func (s *SuggestService) Pretty(pretty bool) *SuggestService

func (*SuggestService) Routing 

func (s *SuggestService) Routing(routing string) *SuggestService

func (*SuggestService) Suggester 

func (s *SuggestService) Suggester(suggester Suggester) *SuggestService

type Suggester 

type Suggester interface {
	Name() string
	Source(includeName bool) interface{}
}

Represents the generic suggester interface. A suggester's only purpose is to return the source of the query as a JSON-serializable object. Returning a map[string]interface{} will do.

type SuggesterCategoryMapping 

type SuggesterCategoryMapping struct {
	// contains filtered or unexported fields
}

SuggesterCategoryMapping provides a mapping for a category context in a suggester. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/suggester-context.html#_category_mapping.

func NewSuggesterCategoryMapping 

func NewSuggesterCategoryMapping(name string) *SuggesterCategoryMapping

NewSuggesterCategoryMapping creates a new SuggesterCategoryMapping.

func (*SuggesterCategoryMapping) DefaultValues 

func (q *SuggesterCategoryMapping) DefaultValues(values ...string) *SuggesterCategoryMapping

func (*SuggesterCategoryMapping) FieldName 

func (q *SuggesterCategoryMapping) FieldName(fieldName string) *SuggesterCategoryMapping

func (*SuggesterCategoryMapping) Source 

func (q *SuggesterCategoryMapping) Source() interface{}

Source returns a map that will be used to serialize the context query as JSON.

type SuggesterCategoryQuery 

type SuggesterCategoryQuery struct {
	// contains filtered or unexported fields
}

SuggesterCategoryQuery provides querying a category context in a suggester. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/suggester-context.html#_category_query.

func NewSuggesterCategoryQuery 

func NewSuggesterCategoryQuery(name string, values ...string) *SuggesterCategoryQuery

NewSuggesterCategoryQuery creates a new SuggesterCategoryQuery.

func (*SuggesterCategoryQuery) Source 

func (q *SuggesterCategoryQuery) Source() interface{}

Source returns a map that will be used to serialize the context query as JSON.

func (*SuggesterCategoryQuery) Values 

func (q *SuggesterCategoryQuery) Values(values ...string) *SuggesterCategoryQuery

type SuggesterContextQuery 

type SuggesterContextQuery interface {
	Source() interface{}
}

SuggesterContextQuery is used to define context information within a suggestion request.

type SuggesterGeoMapping 

type SuggesterGeoMapping struct {
	// contains filtered or unexported fields
}

SuggesterGeoMapping provides a mapping for a geolocation context in a suggester. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/suggester-context.html#_geo_location_mapping.

func NewSuggesterGeoMapping 

func NewSuggesterGeoMapping(name string) *SuggesterGeoMapping

NewSuggesterGeoMapping creates a new SuggesterGeoMapping.

func (*SuggesterGeoMapping) DefaultLocations 

func (q *SuggesterGeoMapping) DefaultLocations(locations ...*GeoPoint) *SuggesterGeoMapping

func (*SuggesterGeoMapping) FieldName 

func (q *SuggesterGeoMapping) FieldName(fieldName string) *SuggesterGeoMapping

func (*SuggesterGeoMapping) Neighbors 

func (q *SuggesterGeoMapping) Neighbors(neighbors bool) *SuggesterGeoMapping

func (*SuggesterGeoMapping) Precision 

func (q *SuggesterGeoMapping) Precision(precision ...string) *SuggesterGeoMapping

func (*SuggesterGeoMapping) Source 

func (q *SuggesterGeoMapping) Source() interface{}

Source returns a map that will be used to serialize the context query as JSON.

type SuggesterGeoQuery 

type SuggesterGeoQuery struct {
	// contains filtered or unexported fields
}

SuggesterGeoQuery provides querying a geolocation context in a suggester. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/suggester-context.html#_geo_location_query

func NewSuggesterGeoQuery 

func NewSuggesterGeoQuery(name string, location *GeoPoint) *SuggesterGeoQuery

NewSuggesterGeoQuery creates a new SuggesterGeoQuery.

func (*SuggesterGeoQuery) Precision 

func (q *SuggesterGeoQuery) Precision(precision ...string) *SuggesterGeoQuery

func (*SuggesterGeoQuery) Source 

func (q *SuggesterGeoQuery) Source() interface{}

Source returns a map that will be used to serialize the context query as JSON.

type Suggestion 

type Suggestion struct {
	Text    string             `json:"text"`
	Offset  int                `json:"offset"`
	Length  int                `json:"length"`
	Options []suggestionOption `json:"options"`
}

type SumAggregation 

type SumAggregation struct {
	// contains filtered or unexported fields
}

SumAggregation is a single-value metrics aggregation that sums up numeric values that are extracted from the aggregated documents. These values can be extracted either from specific numeric fields in the documents, or be generated by a provided script. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-metrics-sum-aggregation.html

func NewSumAggregation 

func NewSumAggregation() SumAggregation

func (SumAggregation) Field 

func (a SumAggregation) Field(field string) SumAggregation

func (SumAggregation) Format 

func (a SumAggregation) Format(format string) SumAggregation

func (SumAggregation) Lang 

func (a SumAggregation) Lang(lang string) SumAggregation

func (SumAggregation) Param 

func (a SumAggregation) Param(name string, value interface{}) SumAggregation

func (SumAggregation) Script 

func (a SumAggregation) Script(script string) SumAggregation

func (SumAggregation) ScriptFile 

func (a SumAggregation) ScriptFile(scriptFile string) SumAggregation

func (SumAggregation) Source 

func (a SumAggregation) Source() interface{}

func (SumAggregation) SubAggregation 

func (a SumAggregation) SubAggregation(name string, subAggregation Aggregation) SumAggregation

type TemplateQuery 

type TemplateQuery struct {
	// contains filtered or unexported fields
}

TemplateQuery is a query that accepts a query template and a map of key/value pairs to fill in template parameters.

For more details, see: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-template-query.html

func NewTemplateQuery 

func NewTemplateQuery(name string) TemplateQuery

NewTemplateQuery creates a new TemplateQuery.

func (TemplateQuery) Source 

func (q TemplateQuery) Source() interface{}

Source returns the JSON serializable content for the search.

func (TemplateQuery) Template 

func (q TemplateQuery) Template(name string) TemplateQuery

Template specifies the name of the template.

func (TemplateQuery) TemplateType 

func (q TemplateQuery) TemplateType(typ string) TemplateQuery

TemplateType defines which kind of query we use. The values can be: inline, indexed, or file. If undefined, inline is used.

func (TemplateQuery) Var 

func (q TemplateQuery) Var(name string, value interface{}) TemplateQuery

Var sets a single parameter pair.

func (TemplateQuery) Vars 

func (q TemplateQuery) Vars(vars map[string]interface{}) TemplateQuery

Vars sets parameters for the template query.

type TermFilter 

type TermFilter struct {
	Filter
	// contains filtered or unexported fields
}

Filters documents that have fields that contain a term (not analyzed). For details, see: http://www.elasticsearch.org/guide/reference/query-dsl/term-filter.html

func NewTermFilter 

func NewTermFilter(name string, value interface{}) TermFilter

func (TermFilter) Cache 

func (f TermFilter) Cache(cache bool) TermFilter

func (TermFilter) CacheKey 

func (f TermFilter) CacheKey(cacheKey string) TermFilter

func (TermFilter) FilterName 

func (f TermFilter) FilterName(filterName string) TermFilter

func (TermFilter) Source 

func (f TermFilter) Source() interface{}

type TermQuery 

type TermQuery struct {
	Query
	// contains filtered or unexported fields
}

A term query matches documents that contain a term (not analyzed). For more details, see http://www.elasticsearch.org/guide/reference/query-dsl/term-query.html

func NewTermQuery 

func NewTermQuery(name string, value interface{}) TermQuery

Creates a new term query.

func (TermQuery) Boost 

func (q TermQuery) Boost(boost float32) TermQuery

func (TermQuery) QueryName 

func (q TermQuery) QueryName(queryName string) TermQuery

func (TermQuery) Source 

func (q TermQuery) Source() interface{}

Creates the query source for the term query.

type TermSuggester 

type TermSuggester struct {
	Suggester
	// contains filtered or unexported fields
}

For more details, see http://www.elasticsearch.org/guide/reference/api/search/term-suggest/

func NewTermSuggester 

func NewTermSuggester(name string) TermSuggester

Creates a new term suggester.

func (TermSuggester) Accuracy 

func (q TermSuggester) Accuracy(accuracy float32) TermSuggester

func (TermSuggester) Analyzer 

func (q TermSuggester) Analyzer(analyzer string) TermSuggester

func (TermSuggester) ContextQueries 

func (q TermSuggester) ContextQueries(queries ...SuggesterContextQuery) TermSuggester

func (TermSuggester) ContextQuery 

func (q TermSuggester) ContextQuery(query SuggesterContextQuery) TermSuggester

func (TermSuggester) Field 

func (q TermSuggester) Field(field string) TermSuggester

func (TermSuggester) MaxEdits 

func (q TermSuggester) MaxEdits(maxEdits int) TermSuggester

func (TermSuggester) MaxInspections 

func (q TermSuggester) MaxInspections(maxInspections int) TermSuggester

func (TermSuggester) MaxTermFreq 

func (q TermSuggester) MaxTermFreq(maxTermFreq float32) TermSuggester

func (TermSuggester) MinDocFreq 

func (q TermSuggester) MinDocFreq(minDocFreq float32) TermSuggester

func (TermSuggester) MinWordLength 

func (q TermSuggester) MinWordLength(minWordLength int) TermSuggester

func (TermSuggester) Name 

func (q TermSuggester) Name() string

func (TermSuggester) PrefixLength 

func (q TermSuggester) PrefixLength(prefixLength int) TermSuggester

func (TermSuggester) ShardSize 

func (q TermSuggester) ShardSize(shardSize int) TermSuggester

func (TermSuggester) Size 

func (q TermSuggester) Size(size int) TermSuggester

func (TermSuggester) Sort 

func (q TermSuggester) Sort(sort string) TermSuggester

func (TermSuggester) Source 

func (q TermSuggester) Source(includeName bool) interface{}

Creates the source for the term suggester.

func (TermSuggester) StringDistance 

func (q TermSuggester) StringDistance(stringDistance string) TermSuggester

func (TermSuggester) SuggestMode 

func (q TermSuggester) SuggestMode(suggestMode string) TermSuggester

func (TermSuggester) Text 

func (q TermSuggester) Text(text string) TermSuggester

type TermVectorsFieldInfo 

type TermVectorsFieldInfo struct {
	FieldStatistics FieldStatistics      `json:"field_statistics"`
	Terms           map[string]TermsInfo `json:"terms"`
}

type TermsAggregation 

type TermsAggregation struct {
	// contains filtered or unexported fields
}

TermsAggregation is a multi-bucket value source based aggregation where buckets are dynamically built - one per unique value. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-terms-aggregation.html

func NewTermsAggregation 

func NewTermsAggregation() TermsAggregation

func (TermsAggregation) CollectionMode 

func (a TermsAggregation) CollectionMode(collectionMode string) TermsAggregation

Collection mode can be depth_first or breadth_first as of 1.4.0.

func (TermsAggregation) Exclude 

func (a TermsAggregation) Exclude(regexp string) TermsAggregation

func (TermsAggregation) ExcludeTerms 

func (a TermsAggregation) ExcludeTerms(terms ...string) TermsAggregation

func (TermsAggregation) ExcludeWithFlags 

func (a TermsAggregation) ExcludeWithFlags(regexp string, flags int) TermsAggregation

func (TermsAggregation) ExecutionHint 

func (a TermsAggregation) ExecutionHint(hint string) TermsAggregation

func (TermsAggregation) Field 

func (a TermsAggregation) Field(field string) TermsAggregation

func (TermsAggregation) Include 

func (a TermsAggregation) Include(regexp string) TermsAggregation

func (TermsAggregation) IncludeTerms 

func (a TermsAggregation) IncludeTerms(terms ...string) TermsAggregation

func (TermsAggregation) IncludeWithFlags 

func (a TermsAggregation) IncludeWithFlags(regexp string, flags int) TermsAggregation

func (TermsAggregation) Lang 

func (a TermsAggregation) Lang(lang string) TermsAggregation

func (TermsAggregation) MinDocCount 

func (a TermsAggregation) MinDocCount(minDocCount int) TermsAggregation

func (TermsAggregation) Order 

func (a TermsAggregation) Order(order string, asc bool) TermsAggregation

func (TermsAggregation) OrderByAggregation 

func (a TermsAggregation) OrderByAggregation(aggName string, asc bool) TermsAggregation

OrderByAggregation creates a bucket ordering strategy which sorts buckets based on a single-valued calc get.

func (TermsAggregation) OrderByAggregationAndMetric 

func (a TermsAggregation) OrderByAggregationAndMetric(aggName, metric string, asc bool) TermsAggregation

OrderByAggregationAndMetric creates a bucket ordering strategy which sorts buckets based on a multi-valued calc get.

func (TermsAggregation) OrderByCount 

func (a TermsAggregation) OrderByCount(asc bool) TermsAggregation

func (TermsAggregation) OrderByCountAsc 

func (a TermsAggregation) OrderByCountAsc() TermsAggregation

func (TermsAggregation) OrderByCountDesc 

func (a TermsAggregation) OrderByCountDesc() TermsAggregation

func (TermsAggregation) OrderByTerm 

func (a TermsAggregation) OrderByTerm(asc bool) TermsAggregation

func (TermsAggregation) OrderByTermAsc 

func (a TermsAggregation) OrderByTermAsc() TermsAggregation

func (TermsAggregation) OrderByTermDesc 

func (a TermsAggregation) OrderByTermDesc() TermsAggregation

func (TermsAggregation) Param 

func (a TermsAggregation) Param(name string, value interface{}) TermsAggregation

func (TermsAggregation) RequiredSize 

func (a TermsAggregation) RequiredSize(requiredSize int) TermsAggregation

func (TermsAggregation) Script 

func (a TermsAggregation) Script(script string) TermsAggregation

func (TermsAggregation) ScriptFile 

func (a TermsAggregation) ScriptFile(scriptFile string) TermsAggregation

func (TermsAggregation) ShardMinDocCount 

func (a TermsAggregation) ShardMinDocCount(shardMinDocCount int) TermsAggregation

func (TermsAggregation) ShardSize 

func (a TermsAggregation) ShardSize(shardSize int) TermsAggregation

func (TermsAggregation) ShowTermDocCountError 

func (a TermsAggregation) ShowTermDocCountError(showTermDocCountError bool) TermsAggregation

func (TermsAggregation) Size 

func (a TermsAggregation) Size(size int) TermsAggregation

func (TermsAggregation) Source 

func (a TermsAggregation) Source() interface{}

func (TermsAggregation) SubAggregation 

func (a TermsAggregation) SubAggregation(name string, subAggregation Aggregation) TermsAggregation

func (TermsAggregation) ValueType 

func (a TermsAggregation) ValueType(valueType string) TermsAggregation

ValueType can be string, long, or double.

type TermsFacet 

type TermsFacet struct {
	// contains filtered or unexported fields
}

Allow to specify field facets that return the N most frequent terms. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-facets-terms-facet.html

func NewTermsFacet 

func NewTermsFacet() TermsFacet

func (TermsFacet) AllTerms 

func (f TermsFacet) AllTerms(allTerms bool) TermsFacet

func (TermsFacet) Comparator 

func (f TermsFacet) Comparator(comparatorType string) TermsFacet

func (TermsFacet) Exclude 

func (f TermsFacet) Exclude(exclude ...string) TermsFacet

func (TermsFacet) ExecutionHint 

func (f TermsFacet) ExecutionHint(hint string) TermsFacet

func (TermsFacet) FacetFilter 

func (f TermsFacet) FacetFilter(filter Facet) TermsFacet

func (TermsFacet) Field 

func (f TermsFacet) Field(fieldName string) TermsFacet

func (TermsFacet) Fields 

func (f TermsFacet) Fields(fields ...string) TermsFacet

func (TermsFacet) Global 

func (f TermsFacet) Global(global bool) TermsFacet

func (TermsFacet) Index 

func (f TermsFacet) Index(index string) TermsFacet

func (TermsFacet) Lang 

func (f TermsFacet) Lang(lang string) TermsFacet

func (TermsFacet) Mode 

func (f TermsFacet) Mode(mode string) TermsFacet

func (TermsFacet) Nested 

func (f TermsFacet) Nested(nested string) TermsFacet

func (TermsFacet) Order 

func (f TermsFacet) Order(order string) TermsFacet

func (TermsFacet) Param 

func (f TermsFacet) Param(name string, value interface{}) TermsFacet

func (TermsFacet) Regex 

func (f TermsFacet) Regex(regex string) TermsFacet

func (TermsFacet) RegexFlags 

func (f TermsFacet) RegexFlags(regexFlags string) TermsFacet

func (TermsFacet) Script 

func (f TermsFacet) Script(script string) TermsFacet

func (TermsFacet) ScriptField 

func (f TermsFacet) ScriptField(scriptField string) TermsFacet

func (TermsFacet) ShardSize 

func (f TermsFacet) ShardSize(shardSize int) TermsFacet

func (TermsFacet) Size 

func (f TermsFacet) Size(size int) TermsFacet

func (TermsFacet) Source 

func (f TermsFacet) Source() interface{}

type TermsFilter 

type TermsFilter struct {
	Filter
	// contains filtered or unexported fields
}

Filters documents that have fields that match any of the provided terms (not analyzed). For details, see: http://www.elasticsearch.org/guide/reference/query-dsl/terms-filter/

func NewTermsFilter 

func NewTermsFilter(name string, values ...interface{}) TermsFilter

func (TermsFilter) Cache 

func (f TermsFilter) Cache(cache bool) TermsFilter

func (TermsFilter) CacheKey 

func (f TermsFilter) CacheKey(cacheKey string) TermsFilter

func (TermsFilter) Execution 

func (f TermsFilter) Execution(execution string) TermsFilter

func (TermsFilter) FilterName 

func (f TermsFilter) FilterName(filterName string) TermsFilter

func (TermsFilter) Source 

func (f TermsFilter) Source() interface{}

type TermsInfo 

type TermsInfo struct {
	DocFreq  int64       `json:"doc_freq"`
	TermFreq int64       `json:"term_freq"`
	Ttf      int64       `json:"ttf"`
	Tokens   []TokenInfo `json:"tokens"`
}

type TermsQuery 

type TermsQuery struct {
	Query
	// contains filtered or unexported fields
}

A query that match on any (configurable) of the provided terms. This is a simpler syntax query for using a bool query with several term queries in the should clauses. For more details, see http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-terms-query.html

func NewTermsQuery 

func NewTermsQuery(name string, values ...interface{}) TermsQuery

NewTermsQuery creates a new terms query.

func (TermsQuery) Boost 

func (q TermsQuery) Boost(boost float32) TermsQuery

func (TermsQuery) DisableCoord 

func (q TermsQuery) DisableCoord(disableCoord bool) TermsQuery

func (TermsQuery) MinimumShouldMatch 

func (q TermsQuery) MinimumShouldMatch(minimumShouldMatch string) TermsQuery

func (TermsQuery) QueryName 

func (q TermsQuery) QueryName(queryName string) TermsQuery

func (TermsQuery) Source 

func (q TermsQuery) Source() interface{}

Creates the query source for the term query.

type TermsStatsFacet 

type TermsStatsFacet struct {
	// contains filtered or unexported fields
}

The terms_stats facet combines both the terms and statistical allowing to compute stats computed on a field, per term value driven by another field. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-facets-terms-stats-facet.html

func NewTermsStatsFacet 

func NewTermsStatsFacet() TermsStatsFacet

func (TermsStatsFacet) AllTerms 

func (f TermsStatsFacet) AllTerms() TermsStatsFacet

func (TermsStatsFacet) FacetFilter 

func (f TermsStatsFacet) FacetFilter(filter Facet) TermsStatsFacet

func (TermsStatsFacet) Global 

func (f TermsStatsFacet) Global(global bool) TermsStatsFacet

func (TermsStatsFacet) KeyField 

func (f TermsStatsFacet) KeyField(keyField string) TermsStatsFacet

func (TermsStatsFacet) Mode 

func (f TermsStatsFacet) Mode(mode string) TermsStatsFacet

func (TermsStatsFacet) Nested 

func (f TermsStatsFacet) Nested(nested string) TermsStatsFacet

func (TermsStatsFacet) Order 

func (f TermsStatsFacet) Order(comparatorType string) TermsStatsFacet

func (TermsStatsFacet) Param 

func (f TermsStatsFacet) Param(name string, value interface{}) TermsStatsFacet

func (TermsStatsFacet) ShardSize 

func (f TermsStatsFacet) ShardSize(shardSize int) TermsStatsFacet

func (TermsStatsFacet) Size 

func (f TermsStatsFacet) Size(size int) TermsStatsFacet

func (TermsStatsFacet) Source 

func (f TermsStatsFacet) Source() interface{}

func (TermsStatsFacet) ValueField 

func (f TermsStatsFacet) ValueField(valueField string) TermsStatsFacet

func (TermsStatsFacet) ValueScript 

func (f TermsStatsFacet) ValueScript(script string) TermsStatsFacet

type TermvectorResponse 

type TermvectorResponse struct {
	Index       string                          `json:"_index"`
	Type        string                          `json:"_type"`
	Id          string                          `json:"_id,omitempty"`
	Version     int                             `json:"_version"`
	Found       bool                            `json:"found"`
	Took        int64                           `json:"took"`
	TermVectors map[string]TermVectorsFieldInfo `json:"term_vectors"`
}

TermvectorResponse is the response of TermvectorService.Do.

type TermvectorService 

type TermvectorService struct {
	// contains filtered or unexported fields
}

TermvectorService returns information and statistics on terms in the fields of a particular document. The document could be stored in the index or artificially provided by the user.

See https://www.elastic.co/guide/en/elasticsearch/reference/1.7/docs-termvectors.html for documentation.

func NewTermvectorService 

func NewTermvectorService(client *Client) *TermvectorService

NewTermvectorService creates a new TermvectorService.

func (*TermvectorService) BodyJson 

func (s *TermvectorService) BodyJson(body interface{}) *TermvectorService

BodyJson defines the body parameters. See documentation.

func (*TermvectorService) BodyString 

func (s *TermvectorService) BodyString(body string) *TermvectorService

BodyString defines the body parameters as a string. See documentation.

func (*TermvectorService) Do 

func (s *TermvectorService) Do() (*TermvectorResponse, error)

Do executes the operation.

func (*TermvectorService) Doc 

func (s *TermvectorService) Doc(doc interface{}) *TermvectorService

Doc is the document to analyze.

func (*TermvectorService) FieldStatistics 

func (s *TermvectorService) FieldStatistics(fieldStatistics bool) *TermvectorService

FieldStatistics specifies if document count, sum of document frequencies and sum of total term frequencies should be returned.

func (*TermvectorService) Fields 

func (s *TermvectorService) Fields(fields ...string) *TermvectorService

Fields a list of fields to return.

func (*TermvectorService) Id 

func (s *TermvectorService) Id(id string) *TermvectorService

Id of the document.

func (*TermvectorService) Index 

func (s *TermvectorService) Index(index string) *TermvectorService

Index in which the document resides.

func (*TermvectorService) Offsets 

func (s *TermvectorService) Offsets(offsets bool) *TermvectorService

Offsets specifies if term offsets should be returned.

func (*TermvectorService) Parent 

func (s *TermvectorService) Parent(parent string) *TermvectorService

Parent id of documents.

func (*TermvectorService) Payloads 

func (s *TermvectorService) Payloads(payloads bool) *TermvectorService

Payloads specifies if term payloads should be returned.

func (*TermvectorService) PerFieldAnalyzer 

func (s *TermvectorService) PerFieldAnalyzer(perFieldAnalyzer map[string]string) *TermvectorService

PerFieldAnalyzer allows to specify a different analyzer than the one at the field.

func (*TermvectorService) Positions 

func (s *TermvectorService) Positions(positions bool) *TermvectorService

Positions specifies if term positions should be returned.

func (*TermvectorService) Preference 

func (s *TermvectorService) Preference(preference string) *TermvectorService

Preference specify the node or shard the operation should be performed on (default: random).

func (*TermvectorService) Pretty 

func (s *TermvectorService) Pretty(pretty bool) *TermvectorService

Pretty indicates that the JSON response be indented and human readable.

func (*TermvectorService) Realtime 

func (s *TermvectorService) Realtime(realtime bool) *TermvectorService

Realtime specifies if request is real-time as opposed to near-real-time (default: true).

func (*TermvectorService) Routing 

func (s *TermvectorService) Routing(routing string) *TermvectorService

Routing is a specific routing value.

func (*TermvectorService) TermStatistics 

func (s *TermvectorService) TermStatistics(termStatistics bool) *TermvectorService

TermStatistics specifies if total term frequency and document frequency should be returned.

func (*TermvectorService) Type 

func (s *TermvectorService) Type(typ string) *TermvectorService

Type of the document.

func (*TermvectorService) Validate 

func (s *TermvectorService) Validate() error

Validate checks if the operation is valid.

type TokenInfo 

type TokenInfo struct {
	StartOffset int64  `json:"start_offset"`
	EndOffset   int64  `json:"end_offset"`
	Position    int64  `json:"position"`
	Payload     string `json:"payload"`
}

type TopHitsAggregation 

type TopHitsAggregation struct {
	// contains filtered or unexported fields
}

TopHitsAggregation keeps track of the most relevant document being aggregated. This aggregator is intended to be used as a sub aggregator, so that the top matching documents can be aggregated per bucket.

It can effectively be used to group result sets by certain fields via a bucket aggregator. One or more bucket aggregators determines by which properties a result set get sliced into.

See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-metrics-top-hits-aggregation.html

func NewTopHitsAggregation 

func NewTopHitsAggregation() TopHitsAggregation

func (TopHitsAggregation) Explain 

func (a TopHitsAggregation) Explain(explain bool) TopHitsAggregation

func (TopHitsAggregation) FetchSource 

func (a TopHitsAggregation) FetchSource(fetchSource bool) TopHitsAggregation

func (TopHitsAggregation) FetchSourceContext 

func (a TopHitsAggregation) FetchSourceContext(fetchSourceContext *FetchSourceContext) TopHitsAggregation

func (TopHitsAggregation) FieldDataField 

func (a TopHitsAggregation) FieldDataField(fieldDataField string) TopHitsAggregation

func (TopHitsAggregation) FieldDataFields 

func (a TopHitsAggregation) FieldDataFields(fieldDataFields ...string) TopHitsAggregation

func (TopHitsAggregation) From 

func (a TopHitsAggregation) From(from int) TopHitsAggregation

func (TopHitsAggregation) Highlight 

func (a TopHitsAggregation) Highlight(highlight *Highlight) TopHitsAggregation

func (TopHitsAggregation) Highlighter 

func (a TopHitsAggregation) Highlighter() *Highlight

func (TopHitsAggregation) NoFields 

func (a TopHitsAggregation) NoFields() TopHitsAggregation

func (TopHitsAggregation) PartialField 

func (a TopHitsAggregation) PartialField(partialField *PartialField) TopHitsAggregation

func (TopHitsAggregation) PartialFields 

func (a TopHitsAggregation) PartialFields(partialFields ...*PartialField) TopHitsAggregation

func (TopHitsAggregation) ScriptField 

func (a TopHitsAggregation) ScriptField(scriptField *ScriptField) TopHitsAggregation

func (TopHitsAggregation) ScriptFields 

func (a TopHitsAggregation) ScriptFields(scriptFields ...*ScriptField) TopHitsAggregation

func (TopHitsAggregation) Size 

func (a TopHitsAggregation) Size(size int) TopHitsAggregation

func (TopHitsAggregation) Sort 

func (a TopHitsAggregation) Sort(field string, ascending bool) TopHitsAggregation

func (TopHitsAggregation) SortBy 

func (a TopHitsAggregation) SortBy(sorter ...Sorter) TopHitsAggregation

func (TopHitsAggregation) SortWithInfo 

func (a TopHitsAggregation) SortWithInfo(info SortInfo) TopHitsAggregation

func (TopHitsAggregation) Source 

func (a TopHitsAggregation) Source() interface{}

func (TopHitsAggregation) TrackScores 

func (a TopHitsAggregation) TrackScores(trackScores bool) TopHitsAggregation

func (TopHitsAggregation) Version 

func (a TopHitsAggregation) Version(version bool) TopHitsAggregation

type TypeFilter 

type TypeFilter struct {
	Filter
	// contains filtered or unexported fields
}

Filters documents matching the provided document / mapping type. Note, this filter can work even when the _type field is not indexed (using the _uid field). For details, see: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-type-filter.html

func NewTypeFilter 

func NewTypeFilter(typ string) TypeFilter

func (TypeFilter) Source 

func (f TypeFilter) Source() interface{}

type UpdateResult 

type UpdateResult struct {
	Index     string     `json:"_index"`
	Type      string     `json:"_type"`
	Id        string     `json:"_id"`
	Version   int        `json:"_version"`
	Created   bool       `json:"created"`
	GetResult *GetResult `json:"get"`
}

UpdateResult is the result of updating a document in Elasticsearch.

type UpdateService 

type UpdateService struct {
	// contains filtered or unexported fields
}

UpdateService updates a document in Elasticsearch. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/docs-update.html for details.

func NewUpdateService 

func NewUpdateService(client *Client) *UpdateService

NewUpdateService creates the service to update documents in Elasticsearch.

func (*UpdateService) ConsistencyLevel 

func (b *UpdateService) ConsistencyLevel(consistencyLevel string) *UpdateService

ConsistencyLevel is one of "one", "quorum", or "all". It sets the write consistency setting for the update operation.

func (*UpdateService) DetectNoop 

func (b *UpdateService) DetectNoop(detectNoop bool) *UpdateService

DetectNoop will instruct Elasticsearch to check if changes will occur when updating via Doc. It there aren't any changes, the request will turn into a no-op.

func (*UpdateService) Do 

func (b *UpdateService) Do() (*UpdateResult, error)

Do executes the update operation.

func (*UpdateService) Doc 

func (b *UpdateService) Doc(doc interface{}) *UpdateService

Doc allows for updating a partial document.

func (*UpdateService) DocAsUpsert 

func (b *UpdateService) DocAsUpsert(docAsUpsert bool) *UpdateService

DocAsUpsert can be used to insert the document if it doesn't already exist.

func (*UpdateService) Fields 

func (b *UpdateService) Fields(fields ...string) *UpdateService

Fields is a list of fields to return in the response.

func (*UpdateService) Id 

func (b *UpdateService) Id(id string) *UpdateService

Id is the identifier of the document to update (required).

func (*UpdateService) Index 

func (b *UpdateService) Index(name string) *UpdateService

Index is the name of the Elasticsearch index (required).

func (*UpdateService) Parent 

func (b *UpdateService) Parent(parent string) *UpdateService

Parent sets the id of the parent document.

func (*UpdateService) Pretty 

func (b *UpdateService) Pretty(pretty bool) *UpdateService

Pretty instructs to return human readable, prettified JSON.

func (*UpdateService) Refresh 

func (b *UpdateService) Refresh(refresh bool) *UpdateService

Refresh the index after performing the update.

func (*UpdateService) ReplicationType 

func (b *UpdateService) ReplicationType(replicationType string) *UpdateService

ReplicationType is one of "sync" or "async".

func (*UpdateService) RetryOnConflict 

func (b *UpdateService) RetryOnConflict(retryOnConflict int) *UpdateService

RetryOnConflict specifies how many times the operation should be retried when a conflict occurs (default: 0).

func (*UpdateService) Routing 

func (b *UpdateService) Routing(routing string) *UpdateService

Routing specifies a specific routing value.

func (*UpdateService) Script 

func (b *UpdateService) Script(script string) *UpdateService

Script is the URL-encoded script definition.

func (*UpdateService) ScriptFile 

func (b *UpdateService) ScriptFile(scriptFile string) *UpdateService

ScriptFile is the file name of a stored script. See https://www.elastic.co/guide/en/elasticsearch/reference/current/modules-scripting.html for details.

func (*UpdateService) ScriptId 

func (b *UpdateService) ScriptId(scriptId string) *UpdateService

ScriptId is the id of a stored script.

func (*UpdateService) ScriptLang 

func (b *UpdateService) ScriptLang(scriptLang string) *UpdateService

ScriptLang defines the scripting language (default: groovy).

func (*UpdateService) ScriptParams 

func (b *UpdateService) ScriptParams(params map[string]interface{}) *UpdateService

func (*UpdateService) ScriptType 

func (b *UpdateService) ScriptType(scriptType string) *UpdateService

func (*UpdateService) ScriptedUpsert 

func (b *UpdateService) ScriptedUpsert(scriptedUpsert bool) *UpdateService

ScriptedUpsert should be set to true if the referenced script (defined in Script or ScriptId) should be called to perform an insert. The default is false.

func (*UpdateService) Timeout 

func (b *UpdateService) Timeout(timeout string) *UpdateService

Timeout is an explicit timeout for the operation, e.g. "1000", "1s" or "500ms".

func (*UpdateService) Type 

func (b *UpdateService) Type(typ string) *UpdateService

Type is the type of the document (required).

func (*UpdateService) Upsert 

func (b *UpdateService) Upsert(doc interface{}) *UpdateService

Upsert can be used to index the document when it doesn't exist yet. Use this e.g. to initialize a document with a default value.

func (*UpdateService) Version 

func (b *UpdateService) Version(version int64) *UpdateService

Version defines the explicit version number for concurrency control.

func (*UpdateService) VersionType 

func (b *UpdateService) VersionType(versionType string) *UpdateService

VersionType is one of "internal" or "force".

type ValueCountAggregation 

type ValueCountAggregation struct {
	// contains filtered or unexported fields
}

ValueCountAggregation is a single-value metrics aggregation that counts the number of values that are extracted from the aggregated documents. These values can be extracted either from specific fields in the documents, or be generated by a provided script. Typically, this aggregator will be used in conjunction with other single-value aggregations. For example, when computing the avg one might be interested in the number of values the average is computed over. See: http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-metrics-valuecount-aggregation.html

func NewValueCountAggregation 

func NewValueCountAggregation() ValueCountAggregation

func (ValueCountAggregation) Field 

func (a ValueCountAggregation) Field(field string) ValueCountAggregation

func (ValueCountAggregation) Format 

func (a ValueCountAggregation) Format(format string) ValueCountAggregation

func (ValueCountAggregation) Lang 

func (a ValueCountAggregation) Lang(lang string) ValueCountAggregation

func (ValueCountAggregation) Param 

func (a ValueCountAggregation) Param(name string, value interface{}) ValueCountAggregation

func (ValueCountAggregation) Script 

func (a ValueCountAggregation) Script(script string) ValueCountAggregation

func (ValueCountAggregation) ScriptFile 

func (a ValueCountAggregation) ScriptFile(scriptFile string) ValueCountAggregation

func (ValueCountAggregation) Source 

func (a ValueCountAggregation) Source() interface{}

func (ValueCountAggregation) SubAggregation 

func (a ValueCountAggregation) SubAggregation(name string, subAggregation Aggregation) ValueCountAggregation

type WeightFactorFunction 

type WeightFactorFunction struct {
	// contains filtered or unexported fields
}

WeightFactorFunction builds a weight factor function that multiplies the weight to the score. See https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-function-score-query.html#_weight for details.

func NewWeightFactorFunction 

func NewWeightFactorFunction(weight float64) WeightFactorFunction

NewWeightFactorFunction initializes and returns a new WeightFactorFunction.

func (WeightFactorFunction) GetWeight 

func (fn WeightFactorFunction) GetWeight() *float64

GetWeight returns the adjusted score. It is part of the ScoreFunction interface. Returns nil if weight is not specified.

func (WeightFactorFunction) Name 

func (fn WeightFactorFunction) Name() string

Name represents the JSON field name under which the output of Source needs to be serialized by FunctionScoreQuery (see FunctionScoreQuery.Source).

func (WeightFactorFunction) Source 

func (fn WeightFactorFunction) Source() interface{}

Source returns the serializable JSON data of this score function.

func (WeightFactorFunction) Weight 

func (fn WeightFactorFunction) Weight(weight float64) WeightFactorFunction

Weight adjusts the score of the score function. See https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-function-score-query.html#_using_function_score for details.

type WildcardQuery 

type WildcardQuery struct {
	Query
	// contains filtered or unexported fields
}

WildcardQuery matches documents that have fields matching a wildcard expression (not analyzed). Supported wildcards are *, which matches any character sequence (including the empty one), and ?, which matches any single character. Note this query can be slow, as it needs to iterate over many terms. In order to prevent extremely slow wildcard queries, a wildcard term should not start with one of the wildcards * or ?. The wildcard query maps to Lucene WildcardQuery.

For more details, see http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-wildcard-query.html.

Example 
package main

import (
	elastic "gopkg.in/olivere/elastic.v2"
)

func main() {
	// Get a client to the local Elasticsearch instance.
	client, err := elastic.NewClient()
	if err != nil {
		// Handle error
		panic(err)
	}

	// Define wildcard query
	q := elastic.NewWildcardQuery("user", "oli*er?").Boost(1.2)
	searchResult, err := client.Search().
		Index("twitter"). // search in index "twitter"
		Query(q).         // use wildcard query defined above
		Do()              // execute
	if err != nil {
		// Handle error
		panic(err)
	}
	_ = searchResult
}

Output:

func NewWildcardQuery 

func NewWildcardQuery(name, wildcard string) WildcardQuery

NewWildcardQuery creates a new wildcard query.

func (WildcardQuery) Boost 

func (q WildcardQuery) Boost(boost float32) WildcardQuery

Boost sets the boost for this query.

func (WildcardQuery) Name 

func (q WildcardQuery) Name(name string) WildcardQuery

Name is the name of the field name.

func (WildcardQuery) QueryName 

func (q WildcardQuery) QueryName(queryName string) WildcardQuery

QueryName sets the name of this query.

func (WildcardQuery) Rewrite 

func (q WildcardQuery) Rewrite(rewrite string) WildcardQuery

Rewrite controls the rewriting. See http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-multi-term-rewrite.html for details.

func (WildcardQuery) Source 

func (q WildcardQuery) Source() interface{}

Source returns the JSON serializable body of this query.

func (WildcardQuery) Wildcard 

func (q WildcardQuery) Wildcard(wildcard string) WildcardQuery

Wildcard is the wildcard to be used in the query, e.g. ki*y??.

Source Files

View all Source files

Directories

Path Synopsis
Package uritemplates is a level 4 implementation of RFC 6570 (URI Template, http://tools.ietf.org/html/rfc6570).
 Package uritemplates is a level 4 implementation of RFC 6570 (URI Template, http://tools.ietf.org/html/rfc6570).

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.