Delen via

SELECT-component (NoSQL-query)

  • Artikel

VAN TOEPASSING OP: NoSQL

Elke query bestaat uit een SELECT component en optioneel FROM en WHERE componenten, volgens ANSI SQL-standaarden. Normaal gesproken wordt de bron in de FROM component geïnventariseerd en de WHERE component past een filter toe op de bron om een subset van JSON-items op te halen. De SELECT component projecteert vervolgens de aangevraagde JSON-waarden in de selectielijst.

Syntaxis

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 ]

Argumenten

Beschrijving
<select_specification> Eigenschappen of waarde die moeten worden geselecteerd voor de resultatenset.
'*' Hiermee geeft u op dat de waarde moet worden opgehaald zonder wijzigingen aan te brengen. Met name als de verwerkte waarde een object is, worden alle eigenschappen opgehaald.
<object_property_list> Hiermee geeft u de lijst met eigenschappen die moeten worden opgehaald. Elke geretourneerde waarde is een object met de opgegeven eigenschappen.
VALUE Hiermee geeft u op dat de JSON-waarde moet worden opgehaald in plaats van het volledige JSON-object. Dit argument betekent niet dat <property_list> de verwachte waarde niet in een object wordt verpakt.
DISTINCT Hiermee geeft u op dat duplicaten van projecteigenschappen moeten worden verwijderd.
<scalar_expression> Expressie die de waarde vertegenwoordigt die moet worden berekend. Zie de sectie scalaire expressies voor meer informatie.

Voorbeelden

In dit eerste voorbeeld worden twee statische tekenreekswaarden geselecteerd en wordt een matrix geretourneerd met één object dat beide waarden bevat. Omdat de waarden geen naam hebben, wordt een opeenvolgend gegenereerd getal gebruikt om het equivalente json-veld een naam te geven.

SELECT "Adventure", "Works"

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

In dit volgende voorbeeld wordt JSON-projectie gebruikt om de exacte structuur en veldnamen voor het resulterende JSON-object nauwkeurig af te stemmen. Hier wordt een JSON-object gemaakt met velden met de naam department en team. Het externe JSON-object is nog steeds niet benoemd, dus er wordt een gegenereerd getal ($1) gebruikt om dit veld een naam te geven.

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

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

Dit voorbeeld illustreert het platmaken van de resultatenset uit het vorige voorbeeld om het parseren te vereenvoudigen. Het VALUE trefwoord wordt hier gebruikt om te voorkomen dat de resultaten in een ander JSON-object worden verpakt.

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

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

In dit voorbeeld wordt het VALUE trefwoord gebruikt met een statische tekenreeks om als resultaat een matrix met tekenreeksen te maken.

SELECT VALUE "Sales"

[
  "Sales"
]

In dit laatste voorbeeld wordt ervan uitgegaan dat er een container is met twee items met verschillende velden van verschillende gegevenstypen.

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

Deze laatste voorbeeldquery maakt gebruik van een combinatie van een SELECT component, het VALUE trefwoord, een FROM component en JSON-projectie om een algemene query uit te voeren met de resultaten die zijn getransformeerd naar een JSON-object om de client te parseren.

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

Opmerkingen

  • De SELECT * syntaxis is alleen geldig als FROM de component precies één alias heeft gedeclareerd. SELECT * biedt een identiteitsprojectie, wat handig kan zijn als er geen projectie nodig is. SELECT * is alleen geldig als FROM de component is opgegeven en slechts één invoerbron heeft geïntroduceerd.
  • Beide SELECT <select_list> en SELECT * zijn "syntactische suiker" en kunnen ook worden uitgedrukt met behulp van eenvoudige SELECT instructies:
    • SELECT * FROM ... AS from_alias ... is gelijk aan: SELECT from_alias FROM ... AS from_alias ....
    • SELECT <expr1> AS p1, <expr2> AS p2,..., <exprN> AS pN [other clauses...] is gelijk aan: SELECT VALUE { p1: <expr1>, p2: <expr2>, ..., pN: <exprN> }[other clauses...].

Gerelateerde inhoud