IMPORTANT: No additional bug fixes or documentation updates will be released for this version. For the latest information, see the current release documentation.

« Running Queries

› ›

Examples

edit

Examples

edit

This sections lists a series of frequent use cases that will help you start with this new API.

This is a work in progress, the documentation will evolve in the future.

Creating an index

edit

For this example on how to create an index, lets create an index named test-index and provide a mapping for the field price which will be an integer. Notice how using the builder for the IntegerNumberProperty will automatically apply the correct value for the type field.

res, err := es.Indices.Create("test-index").
    Request(&create.Request{
        Mappings: &types.TypeMapping{
            Properties: map[string]types.Property{
                "price": types.NewIntegerNumberProperty(),
            },
        },
    }).
    Do(nil)

Indexing a document

edit

The standard way of indexing a document is to provide a struct to the Request method, the standard json/encoder will be run on your structure and the result will be sent to Elasticsearch.

document := struct {
    Id    int    `json:"id"`
    Name  string `json:"name"`
    Price int    `json:"price"`
}{
    Id:    1,
    Name:  "Foo",
    Price: 10,
}

res, err := es.Index("index_name").
    Request(document).
    Do(context.Background())

Alternatively, you can use the Raw method and provide the already serialized JSON:

res, err := es.Index("index_name").
			Raw([]byte(`{
			  "id": 1,
			  "name": "Foo",
			  "price": 10
			}`)).Do(context.Background())

Retrieving a document

edit

Retrieving a document follows the API as part of the argument of the endpoint. In order you provide the index, the id and then run the query:

res, err := es.Get("index_name", "doc_id").Do(context.Background())

Checking for a document existence

edit

If you do not wish to retrieve the content of the document and want only to check if it exists in your index, we provide the IsSuccess shortcut:

if exists, err := es.Exists("index_name", "doc_id").IsSuccess(nil); exists {
    // The document exists !
} else if err != nil {
   // Handle error.
}

Result is true if everything succeeds, false if the document doesn’t exist. If an error occurs during the request, you will be granted with a false and the relevant error.

Search

edit

Building a search query can be done with structs or builder. As an example, let’s search for a document with a field name with a value of Foo in the index named index_name.

With a struct request:

res, err := es.Search().
    Index("index_name"). 
    Request(&search.Request{ 
        Query: &types.Query{
            Match: map[string]types.MatchQuery{
                "name": {Query: "Foo"}, 
            },
        },
    }).Do(context.Background())

	The targeted index for this search.
	The request part of the search.
	Match query specifies that `name` should match `Foo`.
	The query is run with a `context.Background` and returns the response.

It produces the following JSON:

{
  "query": {
    "match": {
      "name": {
        "query": "Foo"
      }
    }
  }
}

Aggregations

edit

Given documents with a price field, we run a sum aggregation on index_name:

totalPricesAgg, err := es.Search().
    Index("index_name"). 
    Request(
        &search.Request{
            Size: some.Int(0), 
            Aggregations: map[string]types.Aggregations{
                "total_prices": { 
                    Sum: &types.SumAggregation{
                        Field: some.String("price"), 
                    },
                },
            },
        },
    ).Do(context.Background())

	Specifies the index name.
	Sets the size to 0 to retrieve only the result of the aggregation.
	Specifies the field name on which the sum aggregation runs.
	The `SumAggregation` is part of the `Aggregations` map.

« Running Queries