【GO】Elasticsearch的简单写入和读取示例

 

 

下载pkg

go get gopkg.in/olivere/elastic.v5

 

修改import项

import "gopkg.in/olivere/elastic.v5"

 

源代码

 

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "reflect"
    "time"

    "gopkg.in/olivere/elastic.v5" // "github.com/olivere/elastic"
)

var (
    index_log_order string = "logisitc_order"
    type_log_order  string = "order"
)

// LogOrder is a structure used for serializing/deserializing data in Elasticsearch.
type LogOrder struct {
    User     string                `json:"user"`
    Message  string                `json:"message"`
    Reorders int                   `json:"reorders"`
    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"`
}

const mapping = `
{
    "settings":{
        "number_of_shards": 1,
        "number_of_replicas": 0
    },
    "mappings":{
        "order":{
            "properties":{
                "user":{
                    "type":"keyword"
                },
                "message":{
                    "type":"text",
                    "store": true,
                    "fielddata": true
                },
                "image":{
                    "type":"keyword"
                },
                "created":{
                    "type":"date"
                },
                "tags":{
                    "type":"keyword"
                },
                "location":{
                    "type":"geo_point"
                },
                "suggest_field":{
                    "type":"completion"
                }
            }
        }
    }
}`

func main() {
    // Starting with elastic.v5, you must pass a context to execute each service
    ctx := context.Background()

    // Obtain a client and connect to the default Elasticsearch installation
    // on 127.0.0.1:9200. Of course you can configure your client to connect
    // to other hosts and configure it in various other ways.
    client, err := elastic.NewClient()
    if err != nil {
        // Handle error
        panic(err)
    }

    // Ping the Elasticsearch server to get e.g. the version number
    info, code, err := client.Ping("http://127.0.0.1:9200").Do(ctx)
    if err != nil {
        // Handle error
        panic(err)
    }
    fmt.Printf("Elasticsearch returned with code %d and version %s\n", 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\n", esversion)

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

    // Index a order (using JSON serialization)
    order1 := LogOrder{User: "olivere", Message: "Take Five", Reorders: 0}
    put1, err := client.Index().
        Index(index_log_order).
        Type(type_log_order).
        Id("1").
        BodyJson(order1).
        Do(ctx)
    if err != nil {
        // Handle error
        panic(err)
    }
    fmt.Printf("Indexed order %s to index %s, type %s\n", put1.Id, put1.Index, put1.Type)

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

    // Get order with specified ID
    get1, err := client.Get().
        Index(index_log_order).
        Type(type_log_order).
        Id("1").
        Do(ctx)
    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(index_log_order).Do(ctx)
    if err != nil {
        panic(err)
    }

    // Search with a term query
    termQuery := elastic.NewTermQuery("user", "olivere")
    searchResult, err := client.Search().
        Index(index_log_order). // search in index index_log_order
        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(ctx)                 // 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 LogOrder
    for _, item := range searchResult.Each(reflect.TypeOf(ttyp)) {
        if t, ok := item.(LogOrder); ok {
            fmt.Printf("LogOrder 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 orders\n", searchResult.TotalHits())

    // Here's how you iterate through results with full control over each step.
    if searchResult.Hits.TotalHits > 0 {
        fmt.Printf("Found a total of %d orders\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 LogOrder (could also be just a map[string]interface{}).
            var t LogOrder
            err := json.Unmarshal(*hit.Source, &t)
            if err != nil {
                // Deserialization failed
            }

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

    // Update a order by the update API of Elasticsearch.
    // We just increment the number of reorders.
    update, err := client.Update().Index(index_log_order).Type(type_log_order).Id("1").
        Script(elastic.NewScriptInline("ctx._source.reorders += params.num").Lang("painless").Param("num", 1)).
        Upsert(map[string]interface{}{"reorders": 0}).
        Do(ctx)
    if err != nil {
        // Handle error
        panic(err)
    }
    fmt.Printf("New version of order %q is now %d\n", update.Id, update.Version)

    // ...

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

 

执行结果

Elasticsearch returned with code 200 and version 6.3.1
Elasticsearch version 6.3.1
Indexed order 1 to index logisitc_order, type order
Indexed order 2 to index logisitc_order, type order
Got document 1 in version 842351749456 from index logisitc_order, type order
Query took 3 milliseconds
LogOrder by olivere: Take Five
LogOrder by olivere: It's a Raggy Waltz
Found a total of 2 orders
Found a total of 2 orders
LogOrder by olivere: Take Five
LogOrder by olivere: It's a Raggy Waltz
New version of order "1" is now 2