﻿---
title: Examples
description: This sections lists a series of frequent use cases that will help you start with this new API. Creating an index, Indexing a document, Retrieving a document,...
url: https://www.elastic.co/elastic/docs-builder/docs/2510/reference/elasticsearch/clients/go/examples
---

# Examples
This sections lists a series of frequent use cases that will help you start with this new API.
- [Creating an index](#indices)
- [Indexing a document](#indexing)
- [Retrieving a document](#retrieving_document)
- [Search](#search)
- [Aggregations](#aggregations)

<note>
  This is a work in progress, the documentation will evolve in the future.
</note>


## Creating an index

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.
```go
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

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.
```go
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:
```go
res, err := es.Index("index_name").
			Raw([]byte(`{
			  "id": 1,
			  "name": "Foo",
			  "price": 10
			}`)).Do(context.Background())
```


## Retrieving a document

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:
```go
res, err := es.Get("index_name", "doc_id").Do(context.Background())
```


## Checking for a document existence

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:
```go
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

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:
```go
res, err := es.Search().
    Index("index_name"). 
    Request(&search.Request{ 
        Query: &types.Query{
            Match: map[string]types.MatchQuery{
                "name": {Query: "Foo"}, 
            },
        },
    }).Do(context.Background()) 
```

It produces the following JSON:
```json
{
  "query": {
    "match": {
      "name": {
        "query": "Foo"
      }
    }
  }
}
```


## Aggregations

Given documents with a `price` field, we run a sum aggregation on `index_name`:
```go
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())
```