SELECT-sats (NoSQL-fråga)

  • Artikel

GÄLLER FÖR: NoSQL

Varje fråga består av en SELECT sats och valfritt FROM och WHERE satser, enligt ANSI SQL-standarder. Vanligtvis räknas källan i FROM -satsen upp och WHERE -satsen tillämpar ett filter på källan för att hämta en delmängd av JSON-objekt. Satsen SELECT projicerar sedan de begärda JSON-värdena i urvalslistan.

Syntax

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 ]

Argument

Description
<select_specification> Egenskaper eller värde som ska väljas för resultatuppsättningen.
'*' Anger att värdet ska hämtas utan att göra några ändringar. Om det bearbetade värdet är ett objekt hämtas alla egenskaper.
<object_property_list> Anger listan över egenskaper som ska hämtas. Varje returnerat värde är ett objekt med de angivna egenskaperna.
VALUE Anger att JSON-värdet ska hämtas i stället för det fullständiga JSON-objektet. Det här argumentet omsluter till skillnad från <property_list> inte det projicerade värdet i ett objekt.
DISTINCT Anger att dubbletter av projicerade egenskaper ska tas bort.
<scalar_expression> Uttryck som representerar det värde som ska beräknas. Mer information finns i avsnittet scalar expressions (skalära uttryck ) för mer information.

Exempel

Det första exemplet väljer två statiska strängvärden och returnerar en matris med ett enda objekt som innehåller båda värdena. Eftersom värdena inte är namngivna används ett sekventiellt genererat tal för att namnge motsvarande json-fält.

SELECT "Adventure", "Works"

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

I nästa exempel används JSON-projektion för att finjustera den exakta strukturen och fältnamnen för det resulterande JSON-objektet. Här skapas ett JSON-objekt med fälten med namnet department och team. Det externa JSON-objektet är fortfarande namnlöst, så ett genererat tal ($1) används för att namnge det här fältet.

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

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

Det här exemplet illustrerar utplattande resultatuppsättningen från föregående exempel för att förenkla parsningen. Nyckelordet VALUE används här för att förhindra omslutning av resultaten i ett annat JSON-objekt.

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

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

I det här exemplet används nyckelordet VALUE med en statisk sträng för att skapa en matris med strängar som resultat.

SELECT VALUE "Sales"

[
  "Sales"
]

I det här sista exemplet förutsätter vi att det finns en container med två objekt med olika fält med olika datatyper.

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

Den här sista exempelfrågan använder en kombination av en SELECT -sats, nyckelordet VALUE , en FROM -sats och JSON-projektion för att utföra en gemensam fråga med resultaten omvandlade till ett JSON-objekt som klienten ska parsa.

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

Kommentarer

  • Syntaxen SELECT * är endast giltig om FROM -satsen har deklarerat exakt ett alias. SELECT * tillhandahåller en identitetsprojektion, vilket kan vara användbart om ingen projektion behövs. SELECT * är endast giltigt om FROM satsen anges och endast introduceras en enda indatakälla.
  • Både SELECT <select_list> och SELECT * är "syntaktisk socker" och kan alternativt uttryckas med hjälp av enkla SELECT instruktioner:
    • SELECT * FROM ... AS from_alias ... motsvarar: SELECT from_alias FROM ... AS from_alias ....
    • SELECT <expr1> AS p1, <expr2> AS p2,..., <exprN> AS pN [other clauses...] motsvarar: SELECT VALUE { p1: <expr1>, p2: <expr2>, ..., pN: <exprN> }[other clauses...].

Relaterat innehåll