Database Search with Go

Let's create a new project folder called databaseSearch:

mkdir databaseSearch

For this code example we'll need Kuzzle's Go SDK. To install it run the following command:

go get github.com/kuzzleio/sdk-go

You should now see the github.com/kuzzleio/sdk-go folder in your go path.

Now the project configuration is complete, we can create a snippet.go file in the databaseSearch folder to program our test.

touch snippet.go

Open the snippet.go file and import the following packages:

import (
    "github.com/kuzzleio/sdk-go/kuzzle"
    "github.com/kuzzleio/sdk-go/types"
    "github.com/kuzzleio/sdk-go/connection/websocket"
    "github.com/kuzzleio/sdk-go/collection"
)

Connect to Kuzzle

The first thing we need to do is connect to Kuzzle. To do this write the following code:

cn := websocket.NewWebSocket("localhost", nil)
k, _ := kuzzle.NewKuzzle(cn, nil)

Here we assume you have installed Kuzzle on your localhost, if this is not the case replace the localhost with the ip or name of the Kuzzle server.

Create a Document

Now that we have established a connection to Kuzzle, we will create a document in our planets collection. To do this, we use the Collection CreateDocument method.

In this case we create a document with name Geonosis and terrain mountain:

c := collection.NewCollection(k, "planets", "galaxies")
q := types.NewQueryOptions()
q.SetIfExist("replace")
planet := c.Document()
planet.Content = []byte(`{"name": "Geonosis", "terrain": "mountain"}`)
c.CreateDocument("", planet, q)

Search for the Document

Now that the document is created and stored in Kuzzle, let's perform a search that will return this document in the result.

First we need to define the search criteria. Here we use the match term to find any document that has a mountain terrain. For additional terms refer to our Elasticsearch Cookbook or Elasticsearch's own documentation.

We use the Collection Search method to search for the document in Kuzzle once the document is created:

filters := &types.SearchFilters{}
filters.Query = json.RawMessage([]byte(`{"match": {"terrain": "mountain"}}`))
result,err := c.Search(filters, nil)

if err != nil {
    handleError(err)
} else {
    //Do something with the matching documents
    doSomething(result)
}

There you have it, a simple bit of code that connects to Kuzzle, creates a document and then fetches that document.

Run the Test

The full code should look something like this:

/* Test Class */

func test(){
    cn := websocket.NewWebSocket("localhost", nil)
    k, _ := kuzzle.NewKuzzle(cn, nil)
    c := collection.NewCollection(k, "planets", "galaxies")

    q := types.NewQueryOptions()
    q.SetIfExist("replace")
    planet := c.Document()
    planet.Content = []byte(`{"name": "Geonosis", "terrain": "mountain"}`)
    c.CreateDocument("", planet, q)

    filters := &types.SearchFilters{}
    filters.Query = json.RawMessage([]byte(`{"match": {"terrain": "mountain"}}`))
    result,err := c.Search(filters, nil)

    if err != nil {
        handleError(err)
    } else {
        //Do something with the matching documents
        doSomething(result)
    }
}

Create a test file using your favorite test framework. For a working example of this code refer to go folder in our snippet test github repository. You can run the test using Visual Studio Code (using the launch.json configuration provided in the repository) or simply by executing the following command in the databaseSearch folder:

go run test.go snippet.go