Clausola SELECT (query NoSQL)

  • Articolo

SI APPLICA A: NoSQL

Ogni query è costituita da una SELECT clausola e, facoltativamente FROM , e WHERE clausole, in base agli standard SQL ANSI. In genere, l'origine nella FROM clausola viene enumerata e la WHERE clausola applica un filtro sull'origine per recuperare un subset di elementi JSON. La SELECT clausola proietta quindi i valori JSON richiesti nell'elenco di selezione.

Sintassi

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 ]

Argomenti

Descrizione
<select_specification> Proprietà o valore da selezionare per il set di risultati.
'*' Specifica che il valore deve essere recuperato senza apportare alcuna modifica. In particolare, se il valore elaborato è un oggetto , vengono recuperate tutte le proprietà.
<object_property_list> Specifica l'elenco di proprietà da recuperare. Ogni valore restituito è un oggetto con le proprietà specificate.
VALUE Specifica che deve essere recuperato il valore JSON anziché l'oggetto JSON completo. Questo argomento, a differenza <property_list> di non esegue il wrapping del valore proiettato in un oggetto .
DISTINCT Specifica che i duplicati delle proprietà proiettate devono essere rimossi.
<scalar_expression> Espressione che rappresenta il valore da calcolare. Per altre informazioni, vedere la sezione Espressioni scalari per informazioni dettagliate.

Esempio

In questo primo esempio vengono selezionati due valori stringa statici e viene restituita una matrice con un singolo oggetto contenente entrambi i valori. Poiché i valori non sono denominati, viene usato un numero generato sequenziale per denominare il campo JSON equivalente.

SELECT "Adventure", "Works"

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

In questo esempio successivo viene usata la proiezione JSON per ottimizzare la struttura esatta e i nomi dei campi per l'oggetto JSON risultante. In questo caso viene creato un oggetto JSON con campi denominati department e team. L'oggetto JSON esterno è ancora senza nome, quindi viene usato un numero generato ($1) per denominare questo campo.

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

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

In questo esempio viene illustrato come rendere flat il set di risultati dell'esempio precedente per semplificare l'analisi. La VALUE parola chiave viene usata qui per impedire il wrapping dei risultati in un altro oggetto JSON.

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

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

In questo esempio la VALUE parola chiave viene usata con una stringa statica per creare una matrice di stringhe come risultato.

SELECT VALUE "Sales"

[
  "Sales"
]

In questo esempio finale si supponga che sia presente un contenitore con due elementi con vari campi di tipi di dati diversi.

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

Questa query di esempio finale usa una combinazione di una SELECT clausola, la VALUE parola chiave, una clausola e la FROM proiezione JSON per eseguire una query comune con i risultati trasformati in un oggetto JSON da analizzare dal client.

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"
  }
]

Commenti

  • La sintassi è valida solo se FROM la SELECT * clausola ha dichiarato esattamente un alias. SELECT * offre una proiezione dell'identità, che può essere utile se non è necessaria alcuna proiezione. SELECT * è valido solo se FROM la clausola viene specificata e introdotta solo una singola origine di input.
  • Sia SELECT <select_list> che SELECT * sono "zucchero sintattico" e possono essere espressi in alternativa usando SELECT semplici istruzioni:
    • SELECT * FROM ... AS from_alias ... equivale a: SELECT from_alias FROM ... AS from_alias ....
    • SELECT <expr1> AS p1, <expr2> AS p2,..., <exprN> AS pN [other clauses...] equivale a: SELECT VALUE { p1: <expr1>, p2: <expr2>, ..., pN: <exprN> }[other clauses...].

Contenuti correlati