Elasticsearch Plugin - Reference Documentation

'elasticSearchClient': FactoryBean threw exception on object creation; nested exception is java.lang.IllegalStateException: path.home is not configured

grails run-app -Des.path.home=<PATH_TO_ELASTICSEARCH_HOME_DIR>

bootRun {
    jvmArgs = ['-Des.path.home=<PATH_TO_ELASTICSEARCH_HOME_DIR>']
}

MyDomain.search("${params.query}")

MyDomain.countHits("${params.query}")

elasticSearch {
  /**
   * Date formats used by the unmarshaller of the JSON responses
   */
  date.formats = ["yyyy-MM-dd'T'HH:mm:ss'Z'"]

  /**
   * Hosts for remote ElasticSearch instances.
   * Will only be used with the "transport" client mode.
   * If the client mode is set to "transport" and no hosts are defined, ["localhost", 9300] will be used by default.
   */
  client.hosts = [
          [host:'localhost', port:9300]
  ]

  /**
   * Default mapping property exclusions
   *
   * No properties matching the given names will be mapped by default
   * i.e., when using "searchable = true"
   *
   * This does not apply for classes using mapping by closure
   */
  defaultExcludedProperties = ["password"]

  /**
   * Determines if the plugin should reflect any database save/update/delete automatically
   * on the ES instance. Default to false.
   */
  disableAutoIndex = false

  /**
   * Should the database be indexed at startup.
   *
   * The value may be a boolean true|false.
   * Indexing is always asynchronous (compared to Searchable plugin) and executed after BootStrap.groovy.
   */
  bulkIndexOnStartup = true

  /**
   *  Max number of requests to process at once. Reduce this value if you have memory issue when indexing a big amount of data
   *  at once. If this setting is not specified, 500 will be use by default.
   */
  maxBulkRequest = 500


  /**
   * The name of the ElasticSearch mapping configuration property that annotates domain classes. The default is 'searchable'.
   */
  searchableProperty.name = 'searchable'
}

environments {
  development {
    /**
     * Possible values : "local", "node", "dataNode", "transport"
     * If set to null, "node" mode is used by default.
     */
    elasticSearch.client.mode = 'local'
  }
  test {
      elasticSearch {
          client.mode = 'local'
          index.store.type = 'memory' // store local node in memory and not on disk
      }
  }
  production {
    elasticSearch.client.mode = 'node'
  }
}

elasticSearch:
    date:
        formats: ["yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"]
    client.hosts:
        - {host: localhost, port: 9300}
    defaultExcludedProperties: ['password']
    disableAutoIndex: false
    index:
        compound_format: true
    unmarshallComponents: true
    searchableProperty:
        name: searchable
    includeTransients: false
environments:
    development:
        elasticSearch:
            client:
                mode: local
                transport.sniff: true
            bulkIndexOnStartup: true
    test:
        elasticSearch:
            client:
                mode: local
                transport.sniff: true
            datastoreImpl: hibernateDatastore
            index:
                store.type: memory
                analysis:
                    filter:
                        replace_synonyms:
                            type: synonym
                            synonyms: ['abc => xyz']
                    analyzer:
                        test_analyzer:
                            tokenizer: standard
                            filter: ['lowercase']
                        repl_analyzer:
                            tokenizer: standard
                            filter: ['lowercase', 'replace_synonyms']

    production:
        elasticSearch:
            client:
                mode: node

static searchable = true

static searchable = {
    // mapping DSL...
}

class Tweet {
    static searchable = {
        only = 'message'
    }
    String message
    String someUselessField
}

class Tweet {
    static searchable = {
        except = 'someUselessField'
    }
    String message
    String someUselessField
}

class Tweet {
    static searchable = {
        except = ['someUselessField', 'userName']
    }
    String message
    String userName
    String someUselessField
}

//assert grailsApplication.config.elasticSearch.includeTransients == false
class Person {
    String firstName
    String lastName
    String getFullName() {
        firstName + " " + lastName
    }
    static transients = ['fullName']
    static searchable = {
        only = ['fullName']
    }
}

// new Person(firstNameme: "Nikola", lastName: "Tesla")
// can be found using:
// def tesla = Person.search("Nikola Tesla").searchResults.first()

//assert grailsApplication.config.elasticSearch.includeTransients == true
class Multiplication {
    int opA
    int opB
    int getResult() {
        opA * opB
    }
    static transients = ['result']
    static searchable = true
}
// new Multiplication(opA: 2, opB: 3)
// can be found using:
// def multiplication = Multiplication.search("2").searchResults.first()
// def multiplication = Multiplication.search("3").searchResults.first()
// def multiplication = Multiplication.search("6").searchResults.first()

class Tweet {
    String message
    List getHashtags() { ... }
    static transients = ['hashtags']
    static hasMany = [hashtags: String]
    static searchable = {only = 'hashtags' }
}

class FamilyGuy {
    String wife
    String son
    String daughter
    String baby
    String[] getRelatives() { ... }
    static transients = ['relatives']
    static searchable = { only = 'relatives' }
}

class Preference {
    static searchable = {
        root false
    }
    // ...
}

class Tag {
    static searchable = true
    // ...
}

class Tweet {
    static searchable = {
        message boost:2.0
    }
    // ...
}

class User {
    static searchable = {
        userPreferences component:true
    }

    Preference userPreferences
}

static searchable = {
  all = [analyzer: 'russian_morphology']
}

static searchable = {
  all = false
}

class MyDomain {
    // odom is an association with the OtherDomain class, set as a reference
    OtherDomain odom

    static searchable = {
        odom reference:true
    }
}

// The OtherDomain definition, with default searchable configuration
class OtherDomain {
    static searchable = true

    String field1 = "val1"
    String field2 = "val2"
    String field3 = "val3"
    String field4 = "val4"
}

{
    "mydomain": {
        "_id":1,
        "odom": { "id":1 }
    }
}

{
    "otherdomain": {
        "_id":1,
        "field1":"val1",
        "field2":"val2",
        "field3":"val3",
        "field4":"val4"
    }
}

class MyDomain {
    // odom is an association with the OtherDomain class, set as a reference
    OtherDomain odom

    static searchable = {
        odom component:true
    }
}

// The OtherDomain definition, with default searchable configuration
class OtherDomain {
    static searchable = true

    String field1 = "val1"
    String field2 = "val2"
    String field3 = "val3"
    String field4 = "val4"
}

{
    "mydomain": {
        "_id":1,
        "odom": {
            "_id":1,
            "field1":"val1",
            "field2":"val2",
            "field3":"val3",
            "field4":"val4"
        }
    }
}

class MyDomain {
    // odom is an association with the OtherDomain class, set as a reference
    OtherDomain odom

    static searchable = {
        odom component: 'inner'
    }
}

Elasticsearch contains
  index 'myapplication.store_v27' with types 'car' and 'motorbike'
  alias 'myapplication.store' pointing to 'myapplication.store_v27'
  'myapplication.store_v27/car' contains 520 documents
  'myapplication.store_v27/motorbike' contains 12 documents
  index 'myapplication.admin_v0' with type 'quote'
  alias 'myapplication.admin' pointing to 'myapplication.admin_v0'
  'myapplication.admin_v0/quote' contains 3200 documents

The application is configured to use indexes based on package names 'myapplication.store' and 'myapplication.admin'
(which as we already explained are actually aliases that point to versioned indices)

The team introduced a change on the Car domain that results in a conflict on the 'car' mapping

The application starts up
    Tries to install the mapping for 'motorbike', it detects the conflict
    Creates a new index called 'myapplication.store_v28'
    Creates mappings 'myapplication.store_v28/car' and 'myapplication.store_v28/motorbike'
    Points all indexing requests for Car and Motorbike to the new index, while queries still happen on 'myapplication.store'
On Boostrap (bulkIndexOnStartup)
    It indexes 520 cars into 'myapplication.store_v28/car'
    It indexes 12 motorbikes into 'myapplication.store_v28/motorbike'
    Switches the 'myapplication.store' alias to point to 'myapplication.store_v28'
    Now all cars are indexed according to the new mapping
    Now all motorbikes are indexed according to the new mapping

def results = Tweet.search("${params.query}", [highlight: { field 'message' }])
def highlighted = results.highlight

results?.searchResults?.eachWithIndex { hit, index ->
    // Retrieve the 'message' field fragments for the current hits
    def fragments = highlighted[index].message?.fragments

    // Print the fragment
    println fragments?.size() ? fragments[0] : ''
}

field <fieldName>, <fragmentSize>, <numberOfFragment>

def highlightSettings = {

    field 'message'                    // Add the 'message' field in the highlighted fields list

    field 'tags.name'                  // Add the 'name' field contained in the 'tags' field of
                                       // the document in the highlighted fields list

    field 'thatAwesomeField', 0, 20    // Add the 'thatAwesomeField' field with
                                       // some values fixed for fragmentSize and
 									   // numberOfFragment parameters
}

def highlightSettings2 = {
    field '_all'                       // Add the special '_all' field in the highlighted
 									   // fields list
}

def results = Tweet.search("${params.query}", [highlight: highlightSettings])
def results2 = Tweet.search("${params.query}", [highlight: highlightSettings2])

def highlightSettings = {
    field 'message'
    preTags '<myAweSomeTag>'
    postTags '</myAweSomeTag>'
}

def sortBuilder = SortBuilders.geoDistanceSort("location")
    .point(48.141, 11.57)
    .unit(DistanceUnit.KILOMETERS)
    .order(SortOrder.ASC)

def result = elasticSearchService.search(
    [indices: Building, types: Building, sort: sortBuilder],
    null as Closure,
    {
        geo_distance(
            'distance': '5km',
            'location': [lat: 48.141, lon: 11.57]
        )
    })

assert [1:[2.34567], 2: [2.4402342]] == result.sort

class Tweet {
  static searchable = {
    message boost:2.0
  }

  static belongsTo = [
          user:User
  ]

  static hasMany = [
          tags:Tag
  ]

  static constraints = {
    tags nullable:true, cascade:'save, update'
  }

  String message = ''
  Date dateCreated = new Date()
}

class User {
  static searchable = {
    except = 'password'
    lastname boost:20
    firstname boost:15, index:'not_analyzed'
    listOfThings index:'no'
    someThings index:'no'
    tweets component:true
  }

  static constraints = {
    tweets cascade:'all'
  }
  static hasMany = [
          tweets:Tweet
  ]
  static mappedBy = [
          tweets:'user'
  ]

  String lastname
  String firstname
  String password
  String activity = 'Evildoer'
  String someThings = 'something'
  ArrayList<String> listOfThings = ['this', 'that', 'andthis']
}

class Tag {
  static searchable = {
    except=['boostValue']
  }

  String name
  Integer boostValue = 1
}

class ElasticSearchController {
  def elasticSearchService
  def testCaseService

  def postTweet = {
    if(!params.user?.id) {
      flash.notice = "No user selected."
      redirect(action: 'index')
      return
    }
    User u = User.get(params.user.id)
    if (!u) {
      flash.notice = "User not found"
      redirect(action: 'index')
      return
    }
    // Create tweet
    testCaseService.addTweet(params.tweet?.message, u, params.tags)

    flash.notice = "Tweet posted"
    redirect(action: 'index')
  }
}

def searchForUserTweets = {
    def tweets = Tweet.search("${params.message.search}").searchResults
    def tweetsMsg = 'Messages : '
    tweets.each {
      tweetsMsg += "<br />Tweet from ${it.user?.firstname} ${it.user?.lastname} : ${it.message} "
      tweetsMsg += "(tags : ${it.tags?.collect{t -> t.name}})"
    }
    flash.notice = tweetsMsg
    redirect(action: 'index')
}

def searchAll = {
    def res = elasticSearchService.search("${params.query}").searchResults
    def resMsg = '<strong>Global search result(s):</strong><br />'
    res.each {
      switch(it){
        case Tag:
          resMsg += "<strong>Tag</strong> ${it.name}<br />"
          break
        case Tweet:
          resMsg += "<strong>Tweet</strong> \"${it.message}\" from ${it.user.firstname} ${it.user.lastname}<br />"
          break
        case User:
          resMsg += "<strong>User</strong> ${it.firstname} ${it.lastname}<br />"
          break
        default:
          resMsg += "<strong>Other</strong> ${it}<br />"
          break
      }

    }
    flash.notice = resMsg
    redirect(action:'index')
 }

class GeoPoint {

    Double lat
    Double lon

    static searchable = {
        root false
    }
}

class Building {

    String name
    GeoPoint location

    static searchable = {
        location geoPoint: true, component: true
    }
}

def searchForBuildings() {
    Closure filter = {
        geo_distance(
            'distance': '5km',
            'location': [lat: 48.141, lon: 11.57]
        )
    }

    def sortBuilder = SortBuilders.geoDistanceSort("location").
        point(48.141, 11.57).
        unit(DistanceUnit.KILOMETERS).
        order(SortOrder.ASC)

    def result = elasticSearchService.search(
        [indices: Building, types: Building, sort: sortBuilder],
        null as Closure,
        filter)

    return [results: result.searchResults, distances: result.sort]
}

assert [1:[23, 42], 2: [24, 40]] == result.sort