Indices

indices are like databases in relational databases.

Also, an index can have an alias.

Aliases are useful for reindex operations without changing application code,

Also can be used for grouping multiple indices with the same name or for create something like SQL views.

Updating an alias

Updating an alias is performed by executing the operation of remove and add the alias, but elastic treats this as an atomic operation.

Index templates

Sometimes, you need to create index on the flight... so, instead of creating the index before inserting your first document, preferred approach is to create an index template.

Sample use case is for logs, when an index per day is created automatically when 1st log line is inserted.

Mappings

Mappings are like the relational database tables... more or less ;)

Mappings could be auto-created on the first document insert, but this is highly not recommended since you can't control accurately the type that the engine are going to assign to each field.

Updating mapping restrictions

• Can't break existing ones
• Can't remove fields, only add
• Can't change analyzer for string fields
• Can't change geo fields precision
• ...

Indexing documents

Here you can PUT, or POST documents like any REST api.

If you use POST, an id will be generated, if PUT is used, previous version of document will be replaced if exists

Important note about indexing

Documents will be saved as inserted, this means that if you insert locations (or dates... or whatever) in different formats, that documents will be retrieved with that inconsistencies.

Searching text

# Looks for exact term
# And yes, a GET request can have body!
curl -XGET "http://localhost:9200/ads/ad/_search" -d '
{
  "query": {
    "term": {
      "zipCode": "08001"
    }
  }
}
' | python -m json.tool

# Short form for simple queries
curl -XGET "http://localhost:9200/ads/ad/_search?q=zipCode:08001"

# Term search for analyzed field
curl -XGET "http://localhost:9200/ads/ad/_search" -d '
{
  "query": {
    "term": {
      "title": "thing"
    }
  }
}
' | python -m json.tool

Term filter

terms search looks for  the term in the 

Array handling

# Saved as received, array fits in any mapping.
curl -XPUT "http://localhost:9200/ads/ad/10" -d'
{
    "id": 10,
    "title": "Anohter one... really?",
    "body": "bahhh.",
    "price": 2000,
    "location": [2.1660139, 41.3791979],
    "zipCode": [ "08001", "08002" ]
}' | python -m json.tool

# Will retrieve all ads
curl -XGET "http://localhost:9200/ads/ad/_search?q=zipCode:08001" | python -m json.tool

# Will retrieve only new ad added in this file, 
# because is the only one with 08002
curl -XGET "http://localhost:9200/ads/ad/_search?q=zipCode:08002" | python -m json.tool

Any field can be an array, no needed mapping option is needed to handle this.

Range search

curl -XGET "http://localhost:9200/ads/ad/_search" -d '
{
  "query": {
    "range": {
      "price": {
        "gte": 15,
        "lte": 20.6
      }
    }
  }
}
' | python -m json.tool

Range searches could be done easily like this

Match search

curl -XGET "http://localhost:9200/ads/ad/_search" -d '
{
  "query": {
    "match": {
      "title": {
        "query": "Another beautiful thing",
        "minimum_should_match": "75%"
       }
    }
  }
}
' | python -m json.tool

Match queries are used to gain control over searched text.

Fuzziness could be specified, also operator for various terms, the analyzer...

Geolocation

Geoqueries are expensive! you should consider how much accuracy do you really need to make searches fast.

WTF!? this is what happens when you interchange lat/long at some point

Geo queries algorithms

Arc: The slowest but most accurate is the arc calculation, which treats the world as a sphere. Accuracy is still limited because the world isn’t really a sphere.

Plane: The plane calculation, which treats the world as if it were flat, is faster but less accurate. It is most accurate at the equator and becomes less accurate toward the poles.

Sloppy arc: So called because it uses the SloppyMath Lucene class to trade accuracy for speed, the sloppy_arccalculation uses the Haversine formula to calculate distance. It is four to five times as fast as arc, and distances are 99.9% accurate. This is the default calculation.

Geohashes

The geohash are a standard to hash locations with the desired preccision in a single value.

Precision goes from 1 to 12

Geo queries

There are many ways to make geolocated queries in elastic search:

• lat/long
• geohash
• bounding box

curl -XGET "http://localhost:9200/ads/ad/_search" -d '
{
  "query": {
    "match_all": {}
  },
  "filter": {
    "geo_distance" : {
      "location" : [ 2.1677398681640625, 41.37794494628906 ],
      "distance" : "2000m",
      "distance_type" : "plane",
      "optimize_bbox" : "indexed"
    }
  },
  "sort" : [
      {
        "_geo_distance" : {
          "location" : [ {
            "lat" : 41.37794494628906,
            "lon" : 2.1677398681640625
          } ],
          "unit" : "m"
        }
      }
  ]
}
' | python -m json.tool