Clause SELECT (requête NoSQL)

  • Article

S’APPLIQUE À : NoSQL

Chaque requête se compose d’une clause SELECT et de clauses FROM et WHERE facultatives, conformément aux normes ANSI-SQL. En règle générale, la source dans la clause FROM est énumérée, tandis que la clause WHERE applique un filtre sur la source pour récupérer un sous-ensemble d’éléments JSON. Ensuite, la clause SELECT projette les valeurs JSON demandées dans la liste sélectionnée.

Syntaxe

SELECT <select_specification>  

<select_specification> ::=
      '*'
      | [DISTINCT] <object_property_list>
      | [DISTINCT] VALUE <scalar_expression> [[ AS ] value_alias]  
  
<object_property_list> ::=
{ <scalar_expression> [ [ AS ] property_alias ] } [ ,...n ]

Arguments

Description
<select_specification> Propriétés ou valeur à sélectionner pour le jeu de résultats.
'*' Spécifie que la valeur doit être récupérée sans apporter de modifications. Plus spécifiquement, si la valeur traitée est un objet, toutes les propriétés sont récupérées.
<object_property_list> Spécifie la liste des propriétés à récupérer. Chaque valeur retournée est un objet avec les propriétés spécifiées.
VALUE Spécifie que la valeur JSON doit être récupérée au lieu de l’objet JSON complet. Cet argument, différemment de <property_list>, n’encapsule pas la valeur projetée dans un objet.
DISTINCT Spécifie que les doublons de propriétés projetées doivent être supprimés.
<scalar_expression> Expression représentant la valeur à calculer. Pour plus d’informations, consultez la section Expressions scalaires pour plus d’informations.

Exemples

Ce premier exemple sélectionne deux valeurs de chaîne statique et retourne un tableau avec un seul objet contenant les deux valeurs. Étant donné que les valeurs ne sont pas nommées, un nombre généré séquentiel est utilisé pour nommer le champ JSON équivalent.

SELECT "Adventure", "Works"

[
  {
    "$1": "Adventure",
    "$2": "Works"
  }
]

Dans cet exemple suivant, la projection JSON est utilisée pour affiner la structure et les noms de champ exacts de l’objet JSON résultant. Ici, un objet JSON est créé avec des champs nommés department et team. L’objet JSON externe n’étant pas nommé, un nombre généré ($1) est utilisé pour nommer ce champ.

SELECT {
    department: "Sales",
    team: "Field sales"
}

[
  {
    "$1": {
      "department": "Sales",
      "team": "Field sales"
    }
  }
]

Cet exemple illustre l’aplatissement des résultats de l’exemple précédent pour simplifier l’analyse. Le mot clé VALUE est utilisé ici pour empêcher l’encapsulage des résultats dans un autre objet JSON.

SELECT VALUE {
    department: "Sales",
    team: "Field sales"
}

[
  {
    "department": "Sales",
    "team": "Field sales"
  }
]

Dans cet exemple, le mot clé VALUE est utilisé avec une chaîne statique pour créer un tableau de chaînes comme résultat.

SELECT VALUE "Sales"

[
  "Sales"
]

Dans cet exemple final, supposons qu’il existe un conteneur avec deux éléments ayant plusieurs champs de différents types de données.

[
  {
    "team": "Field sales",
    "identity": {
      "name": "Parker McLean"
    },
    "contact": [
      "206-555-0147"
    ]
  },
  {
    "team": "Field sales",
    "identity": {
      "name": "Beibit Shayakhmet"
    },
    "contact": [
      "206-555-0178"
    ]
  }
]

Cet exemple de requête final utilise une combinaison d’une clause SELECT, du mot clé VALUE, d’une clause FROM et d’une projection JSON pour effectuer une requête courante avec les résultats transformés en objet JSON pour que le client puisse analyser.

SELECT VALUE {
    name: e.identity.name,
    team: e.team,
    phone: e.contact[0]
}
FROM
    employees e

[
  {
    "name": "Parker McLean",
    "team": "Field sales",
    "phone": "206-555-0147"
  },
  {
    "name": "Beibit Shayakhmet",
    "team": "Field sales",
    "phone": "206-555-0178"
  }
]

Notes 

  • La syntaxe SELECT * est valide uniquement si la clause FROM a déclaré exactement un alias. SELECT * fournit une projection d’identité, ce qui peut être utile si aucune projection n’est nécessaire. SELECT * est valide uniquement si la clause FROM est spécifiée et n’a introduit qu’une seule source d’entrée.
  • SELECT <select_list> et SELECT * sont ce qu’on appelle du « sucre syntaxique » et que vous pouvez également les exprimer à l’aide de simples instructions SELECT :
    • SELECT * FROM ... AS from_alias ... équivaut à : SELECT from_alias FROM ... AS from_alias ....
    • SELECT <expr1> AS p1, <expr2> AS p2,..., <exprN> AS pN [other clauses...] équivaut à : SELECT VALUE { p1: <expr1>, p2: <expr2>, ..., pN: <exprN> }[other clauses...].

Contenu connexe