Elasticsearch
Verschil tussen relationele databases en Elasticsearch

C# Language Django Java Language MongoDB Node.js PHP Python Language Ruby Language Ruby on Rails symfony2

Invoering

Dit is voor de lezers die afkomstig zijn uit een relationele achtergrond en die elastische zoekopdrachten willen leren. Dit onderwerp toont de use cases waarvoor relationele databases geen geschikte optie zijn.

Terminologieverschil

Relationele database	Elasticsearch
Database	Inhoudsopgave
Tafel	Type
Rij / Record	Document
Kolomnaam	veld-

Bovenstaande tabel trekt ruwweg een analogie tussen basiselementen van relationele database en elastisch zoeken.

Opstelling

Overweeg de volgende structuur in een relationele database:

create databse test;

use test;

create table product;

create table product (name varchar, id int PRIMARY KEY);

insert into product  (id,name) VALUES (1,'Shirt');

insert into product  (id,name) VALUES (2,'Red Shirt');

select * from product;

name      | id 
----------+----
Shirt     |  1
Red Shirt |  2

Elastiekzoeker gelijkwaardig:

POST test/product
{
    "id" : 1,
    "name" : "Shirt"
}

POST test/product
{
    "id" : 2,
    "name" : "Red Shirt"
}

GET test/product/_search


"hits": [
     {                                      ==============
        "_index": "test",                   ===> index    |
        "_type": "product",                 ===>type      |
        "_id": "AVzglFomaus3G2tXc6sB",                    |
        "_score": 1,                                      |
        "_source": {                                      |===> document
           "id": 2,                        ===>field      | 
           "name": "Red Shirt"             ===>field      |
        }                                                 |
     },                                     ==============
     {
        "_index": "test",
        "_type": "product",
        "_id": "AVzglD12aus3G2tXc6sA",
        "_score": 1,
        "_source": {
           "id": 1,                 
           "name": "Shirt"           
        }
     }
  ]

Gebruikssituaties waarbij relationele databases niet geschikt zijn

Essentie van zoeken ligt in zijn volgorde. Iedereen wil dat zoekresultaten zo worden weergegeven dat de best passende resultaten bovenaan worden weergegeven. Relationele databases beschikken niet over dergelijke mogelijkheden. Elasticsearch daarentegen geeft standaard resultaten weer op basis van relevantie.
Opstelling
Hetzelfde als in het vorige voorbeeld.
Probleemstelling
Stel dat gebruiker wil om te zoeken naar shirts maar hij is geïnteresseerd in het red gekleurde shirts. In dat geval moeten resultaten met het trefwoord red en shirts bovenaan staan. Dan moeten resultaten voor andere shirts achter hen worden getoond.
Oplossing met behulp van relationele databasequery
select * from product where name like '%Red%' or name like '%Shirt%' ;
uitgang
```
name       | id 
-----------+----
Shirt      |  1
Red Shirt  |  2
```
Elasticsearch-oplossing
```
POST test/product/_search
{
     "query": {
          "match": {
            "name": "Red Shirt"
         }
     }
}
```
uitgang
```
"hits": [
  {
     "_index": "test",
     "_type": "product",
     "_id": "AVzglFomaus3G2tXc6sB",
     "_score": 1.2422675,              ===> Notice this
     "_source": {
        "id": 2,
        "name": "Red Shirt"
     }
  },
  {
     "_index": "test",
     "_type": "product",
     "_id": "AVzglD12aus3G2tXc6sA",
     "_score": 0.25427115,             ===> Notice this
     "_source": {
        "id": 1,
        "name": "Shirt"
     }
  }
 ]
```
Conclusie
Zoals we hierboven kunnen zien, heeft Relationele database resultaten in een willekeurige volgorde geretourneerd, terwijl Elasticsearch resultaten oplevert in afnemende volgorde van _score die wordt berekend op basis van relevantie.

We hebben de neiging om fouten te maken bij het invoeren van de zoekreeks. Er zijn gevallen waarin de gebruiker een onjuiste zoekparameter invoert. Relationele databases zullen dergelijke gevallen niet behandelen. Elasticsearch te hulp.
Opstelling
Hetzelfde als in het vorige voorbeeld.
Probleemstelling
Stel dat de gebruiker naar shirts wil zoeken, maar dat hij per ongeluk een onjuist woord shrt . Gebruiker verwacht nog steeds de resultaten van het shirt te zien .
Oplossing met behulp van relationele databasequery
select * from product where name like '%shrt%' ;
uitgang
```
No results found
```
Elasticsearch-oplossing
```
POST /test/product/_search

 {
    "query": {
      "match": {
        "name": {
          "query": "shrt",
          "fuzziness": 2,
          "prefix_length": 0
         }
      }
    }
 }  
```
uitgang
```
 "hits": [
  {
     "_index": "test",
     "_type": "product",
     "_id": "AVzglD12aus3G2tXc6sA",
     "_score": 1,
     "_source": {
        "id": 1,
        "name": "Shirt"
     }
  },
  {
     "_index": "test",
     "_type": "product",
     "_id": "AVzglFomaus3G2tXc6sB",
     "_score": 0.8784157,
     "_source": {
        "id": 2,
        "name": "Red Shirt"
     }
  }
]
```
Conclusie
Zoals we hierboven kunnen zien, heeft de relationele database geen resultaten opgeleverd voor een gezocht woord, terwijl Elasticsearch met zijn speciale fuzzy zoekopdracht resultaten oplevert.

Modified text is an extract of the original Stack Overflow Documentation

Licentie onder CC BY-SA 3.0

Niet aangesloten bij Stack Overflow