Types de Données Principaux

Type	Description	Scénario d'Utilisation
text	Champ pour la recherche plein texte, analysé par un tokenizer	Contenu d'article, descriptions, commentaires
keyword	Champ pour des valeurs exactes, non analysé	Code de statut, tags, identifiants, valeurs énumérées
long	Entier 64 bits	Quantités, identifiants, horodatages

Langage de Requête DSL (Domain Specific Language)

Format JSON permettant des requêtes, filtres et agrégations complexes.

1. Structure Globale d'une Requête DSL

{
  "query": { ... },          // Critères de recherche
  "aggs": { ... },           // Agrégations analytiques
  "sort": { ... },           // Tri
  "from": 0,                 // Pagination : offset
  "size": 10,                // Nombre de résultats
  "_source": { ... },        // Contrôle des champs retournés
  "highlight": { ... }       // Mise en surbrillance
}

2. Requêtes Textuelles (Full-Text)

Principalement pour chercher dans les champs de type text. Le texte de la requête est lui aussi analysé.

2.1 Requête match

Analyse le texte de la requête comme le champ ciblé. Insensible à la casse.

// Syntaxe complète
{
  "query": {
    "match": {
      "nom_du_champ": {
        "query": "texte à chercher",
        "operator": "or",               // Optionnel : or/and
        "minimum_should_match": "75%",  // Optionnel
        "fuzziness": "AUTO",            // Optionnel : tolérance aux fautes
        "analyzer": "standard"          // Optionnel
      }
    }
  }
}

Exemple simple : Chercher des produits dont la description contient l'un des termes "sans fil" ou "écouteurs".

GET /catalogue_produits/_search
{
  "query": {
    "match": {
      "description_courte": "écouteurs sans fil"
    }
  }
}

Paramètre operator : Pour exiger que tous les termes soient présents (opérateur AND).

GET /articles_techniques/_search
{
  "query": {
    "match": {
      "corps_du_texte": {
        "query": "configuration cluster",
        "operator": "and"
      }
    }
  }
}

Paramètre minimum_should_match : Spécifie le nombre minimal de termes qui doivent correspondre.

GET /news/_search
{
  "query": {
    "match": {
      "titre": {
        "query": "analyse données intelligence artificielle",
        "minimum_should_match": 2
      }
    }
  }
}

Paramètre fuzziness : Permet une correspondance approximative pour gérer les fautes de frappe.

GET /annuaire/_search
{
  "query": {
    "match": {
      "nom": {
        "query": "jean",
        "fuzziness": "AUTO"
      }
    }
  }
}

Paramètre analyzer : Spécifie l'analyseur à utiliser, par exemple pour le chinois.

GET /articles_cn/_search
{
  "query": {
    "match": {
      "contenu": {
        "query": "apprentissage automatique",
        "analyzer": "ik_smart"
      }
    }
  }
}

2.2 Requête match_phrase

Recherche une phrase exacte, les termes doivent apparaître dans l'ordre et de manière contiguë. La proximité peut être configurée.

// Syntaxe complète
{
  "query": {
    "match_phrase": {
      "nom_du_champ": {
        "query": "phrase exacte",
        "slop": 0,                 // Optionnel : nombre de termes autorisés entre les mots clés
        "analyzer": "standard"     // Optionnel
      }
    }
  }
}

Exemple : Chercher la phrase "apprentissage profond".

GET /documentation/_search
{
  "query": {
    "match_phrase": {
      "contenu": "apprentissage profond"
    }
  }
}

Paramètre slop : Autorise une distance maximale (en nombre de termes) entre les mots de la phrase.

GET /livres/_search
{
  "query": {
    "match_phrase": {
      "titre": {
        "query": "données massives",
        "slop": 1
      }
    }
  }
}

Ceci pourrait correspondre à "données très massives" mais pas à "massives données".

2.3 Requête multi_match

Effectue une recherche match sur plusieurs champs. Permet d'attribuer des poids différents aux champs.

// Syntaxe de base
{
  "query": {
    "multi_match": {
      "query": "texte à chercher",
      "fields": ["champ1", "champ2^3", "champ3"], // Le ^ indique un boost de pertinence
      "type": "best_fields",
      "tie_breaker": 0.3,
      "minimum_should_match": "75%"
    }
  }
}

Exemple : Chercher dans le titre, la description et le résumé.

POST /articles/_search
{
  "query": {
    "multi_match": {
      "query": "réseau neuronal",
      "fields": ["titre", "description", "resume"]
    }
  }
}

3. Requêtes Exactes

3.1 Requête term

Recherche une valeur exacte sans analyse (non tokenisée). Sensible à la casse. Idéale pour les champs keyword, les nombres, les dates.

// Syntaxe de base
{
  "query": {
    "term": {
      "nom_du_champ": {
        "value": "valeur_exacte",
        "boost": 1.0 // Optionnel : poids
      }
    }
  }
}

Attention : Ne pas utiliser directement sur un champ text qui a été analysé. Utilisez son sous-champ .keyword s'il existe.

// Recherche d'un statut précis
GET /commandes/_search
{
  "query": {
    "term": {
      "statut": "LIVREE"
    }
  }
}

3.2 Requête terms

Recherche plusieurs valeurs exactes (équivalent SQL IN(...)). Efficace avec un index inversé.

{
  "query": {
    "terms": {
      "nom_du_champ": [
        "valeur1",
        "valeur2",
        "valeur3"
      ]
    }
  }
}

Exemple : Trouver les produits de catégories spécifiques.

GET /produits/_search
{
  "query": {
    "terms": {
      "categorie_id": ["tech", "multimedia", "accessoires"]
    }
  }
}

4. Requêtes Composées (Booléennes)

Permettent de combiner plusieurs conditions de manière logique.

4.1 Le conteneur bool

{
  "query": {
    "bool": {
      "must": [ ... ],       // Toutes ces clauses DOIVENT correspondre (ET logique)
      "should": [ ... ],     // Au moins une de ces clauses DOIT correspondre (OU logique)
      "must_not": [ ... ],   // Aucune de ces clauses ne doit correspondre (NON logique)
      "filter": [ ... ]      // Doivent correspondre, sans impact sur le score de pertinence
    }
  }
}

Le bloc must

GET /logements/_search
{
  "query": {
    "bool": {
      "must": [
        { "match": { "description": "lumineux balcon" } },
        { "term": { "ville": "Paris" } },
        { "range": { "loyer_mensuel": { "lte": 1500 } } }
      ]
    }
  }
}

Le bloc filter

Comme must, mais les conditions sont utilisées uniquement pour le filtrage (vrai/faux). Le score de pertinence n'est pas calculé pour ces clauses, ce qui améliore les performances. Idéal pour les champs exacts (keyword, date, nombre).

GET /evenements/_search
{
  "query": {
    "bool": {
      "filter": [
        { "term": { "type": "conference" } },
        { "range": { "date_debut": { "gte": "now/d" } } }
      ]
    }
  }
}

Le bloc should

Le comportement dépend du contexte :

• Sans must ni filter : au moins une condition should doit correspondre (OU logique).
• Avec must ou filter : les conditions should deviennent de simples bonus qui améliorent le score, mais ne sont pas obligatoires.

// Exemple avec should comme filtre optionnel (bonus)
GET /produits/_search
{
  "query": {
    "bool": {
      "filter": [
        { "term": { "marque": "Samsung" } }
      ],
      "should": [
        { "term": { "en_promotion": true } },
        { "range": { "note_moyenne": { "gte": 4.5 } } }
      ]
    }
  }
}

5. Agrégations (Aggregations)

Permettent d'analyser et de résumer les données.

5.1 Agrégations par Seau (Bucket Aggregations)

Regroupent les documents dans des "seaux" selon des critères. Exemple classique : terms.

GET /ventes/_search
{
  "size": 0,
  "aggs": {
    "par_categorie": {
      "terms": {
        "field": "categorie",
        "size": 10
      }
    }
  }
}

5.2 Agrégations Métriques (Metric Aggregations)

Calculent des statistiques sur un ensemble de documents.

GET /mesures/_search
{
  "size": 0,
  "aggs": {
    "temperature_moyenne": {
      "avg": { "field": "temperature" }
    },
    "temperature_max": {
      "max": { "field": "temperature" }
    }
  }
}