Gruppierung sortieren und Daten einschränken

Wenn Sie die Beispiele befolgen möchten, finden Sie weitere Informationen unter zum Anzeigen von Beispieldaten und zum Laden von Beispieldaten zum Testen. Die Skripte erstellen die in den Beispielen verwendeten Tabellen und laden Daten in die Tabellen.

Wenn Sie die Beispiele befolgen möchten, finden Sie unter Beispieldaten zum Ausführen von Abfragen Informationen zum Anzeigen von Beispieldaten und zum Erstellen der Beispieltabellen mit der OCI-Konsole und zum Laden von Daten mit JSON-Dateien.

Verwandte Themen

Anforderungsergebnisse

Verwenden Sie die ORDER BY-Klausel, um die Ergebnisse nach beliebigen Spalten, Primärschlüsseln oder Nicht-Primärschlüsseln zu sortieren.

Beispiel 1: Sortieren Sie die Ticketnummer aller Passagiere nach ihrem vollständigen Namen.
SELECT bag.ticketNo, bag.fullName 
FROM BaggageInfo bag 
ORDER BY bag.fullName

Erläuterung: Sie sortieren die Ticketnummer der Passagiere im Schema BaggageInfo nach dem vollständigen Namen der Passagiere in aufsteigender Reihenfolge.

Ausgabe: 
{"ticketNo":1762344493810,"fullName":"Adam Phillips"}
{"ticketNo":1762392135540,"fullName":"Adelaide Willard"}
{"ticketNo":1762376407826,"fullName":"Dierdre Amador"}
{"ticketNo":1762355527825,"fullName":"Doris Martin"}
{"ticketNo":1762324912391,"fullName":"Elane Lemons"}
{"ticketNo":1762350390409,"fullName":"Fallon Clements"}
{"ticketNo":1762341772625,"fullName":"Gerard Greene"}
{"ticketNo":176234463813,"fullName":"Henry Jenkins"}
{"ticketNo":1762383911861,"fullName":"Joanne Diaz"}
{"ticketNo":1762377974281,"fullName":"Kendal Biddle"}
{"ticketNo":1762355854464,"fullName":"Lisbeth Wampler"}
{"ticketNo":1762320369957,"fullName":"Lorenzo Phil"}
{"ticketNo":1762320569757,"fullName":"Lucinda Beckman"}
{"ticketNo":1762340683564,"fullName":"Mary Watson"}
{"ticketNo":1762330498104,"fullName":"Michelle Payne"}
{"ticketNo":1762348904343,"fullName":"Omar Harvey"}
{"ticketNo":1762399766476,"fullName":"Raymond Griffin"}
{"ticketNo":1762311547917,"fullName":"Rosalia Triplett"}
{"ticketNo":1762357254392,"fullName":"Teena Colley"}
{"ticketNo":1762390789239,"fullName":"Zina Christenson"}
{"ticketNo":1762340579411,"fullName":"Zulema Martindale"}
Beispiel 2: Rufen Sie die Passagierdaten (Vollname, Tag-Nummer) nach der zuletzt angezeigten Zeit (letzte zuerst) für Passagiere (sortiert nach ihrem Namen) ab, deren zuletzt angezeigte Station MEL ist.
SELECT bag.fullName, bag.bagInfo[].tagNum, 
bag.bagInfo[].lastSeenTimeGmt
FROM BaggageInfo bag 
WHERE bag.bagInfo[].lastSeenStation=any "MEL"
ORDER BY bag.bagInfo[].lastSeenTimeGmt DESC
Erläuterung: Sie filtern zuerst die Daten in der Tabelle BaggageInfo basierend auf der zuletzt angezeigten Station und sortieren die gefilterten Ergebnisse nach der zuletzt angezeigten Zeit und dem vollständigen Namen der Passagiere in absteigender Reihenfolge. Dazu verwenden Sie die ORDER BY-Klausel.

Hinweis:

Sie können die Ausgabe der Abfrage mit mehr als einer Spalte sortieren.
Ausgabe: 
{"fullName":"Adam Phillips","tagNum":"17657806255240","lastSeenTimeGmt":"2019-02-01T16:13:00Z"}
{"fullName":"Zina Christenson","tagNum":"17657806228676","lastSeenTimeGmt":"2019-02-04T10:08:00Z"}
{"fullName":"Joanne Diaz","tagNum":"17657806292518","lastSeenTimeGmt":"2019-02-16T16:13:00Z"}
{"fullName":"Zulema Martindale","tagNum":"17657806288937","lastSeenTimeGmt":"2019-02-25T20:15:00Z"}

Ergebnisse begrenzen und verschieben

Verwenden Sie die Klausel LIMIT, um die Anzahl der Ergebnisse zu begrenzen, die von einer SELECT-Anweisung zurückgegeben werden. Beispiel: Wenn eine Tabelle 1000 Zeilen enthält, begrenzen Sie die Anzahl der zurückzugebenden Zeilen, indem Sie einen LIMIT-Wert angeben. Es wird empfohlen, LIMIT und OFFSET mit einer ORDER BY-Klausel zu verwenden. Andernfalls werden die Ergebnisse in zufälliger Reihenfolge zurückgegeben, was zu unvorhersehbaren Ergebnissen führt.

Ein gutes Anwendungsbeispiel für die Verwendung von LIMIT und OFFSET ist das Anwendungspaging von Ergebnissen. Beispiel: Ihre Anwendung möchte 4 Ergebnisse pro Seite anzeigen. Mit Limit und Offset können Sie zustandsloses Paging in der Anwendung implementieren. Wenn Sie n (z.B. 4 ) Ergebnisse pro Seite anzeigen, werden die Ergebnisse für Seite m (z.B. 2) angezeigt, dann wäre der Offset (n*m-1), der in diesem Beispiel 4 ist, und der Grenzwert wäre n (der hier 4 ist).

Beispiel 1: Ihre Anwendung kann 4 Ergebnisse auf einer Seite anzeigen. Rufen Sie die Details ab, die Ihre Anwendung auf der ersten Seite für Passagiere abgerufen hat, deren zuletzt gesehener Bahnhof JTR ist.
SELECT $bag.fullName, $bag.bagInfo.tagNum, $flt_time
FROM BaggageInfo $bag, 
$bag.bagInfo[].lastSeenTimeGmt $flt_time
WHERE $bag.bagInfo[].lastSeenStation=any "JTR" 
ORDER BY $flt_time LIMIT 4

Erläuterung: Sie filtern die Daten in der Tabelle BaggageInfo basierend auf der zuletzt angezeigten Station und sortieren das Ergebnis basierend auf der zuletzt angezeigten Zeit. Sie verwenden ein unnest-Array, um Ihre Daten zu vereinfachen. Das bagInfo-Array ist abgeflacht, und die zuletzt gesuchte Zeit wird abgerufen. Sie müssen nur die ersten 4 Zeilen aus der Ergebnismenge anzeigen.

Ausgabe:
{"fullName":"Michelle Payne","tagNum":"17657806247861","flt_time":"2019-02-02T23:59:00Z"}
{"fullName":"Gerard Greene","tagNum":"1765780626568","flt_time":"2019-03-07T16:01:00Z"}
{"fullName":"Lorenzo Phil","tagNum":["17657806240001","17657806340001"],"flt_time":"2019-03-12T15:05:00Z"}
{"fullName":"Lucinda Beckman","tagNum":"17657806240001","flt_time":"2019-03-12T15:05:00Z"}
Beispiel 2: Ihre Anwendung kann 4 Ergebnisse auf einer Seite anzeigen. Rufen Sie die Details ab, die Ihre Anwendung auf der zweiten Seite für Passagiere abgerufen hat, deren zuletzt gesehener Bahnhof JTR ist.
SELECT $bag.fullName, $bag.bagInfo.tagNum, $flt_time 
FROM BaggageInfo $bag, 
$bag.bagInfo[].lastSeenTimeGmt $flt_time 
WHERE $bag.bagInfo[].lastSeenStation=any "JTR" 
ORDER BY $flt_time LIMIT 4 OFFSET 4

Erläuterung: Sie filtern die Daten in der Tabelle BaggageInfo basierend auf der zuletzt angezeigten Station und sortieren das Ergebnis basierend auf der zuletzt angezeigten Zeit. Sie verwenden ein unnest-Array, um Ihre Daten zu vereinfachen. Sie müssen den Inhalt der zweiten Seite anzeigen, sodass Sie einen OFFSET 4 festlegen. Obwohl Sie auf 4 Zeilen beschränken, wird nur eine Zeile angezeigt, da die Gesamtergebnismenge nur 5 beträgt. Die ersten werden übersprungen und die fünfte wird angezeigt.

Ausgabe: 
{"fullName":"Lorenzo Phil","tagNum":["17657806240001","17657806340001"],
"flt_time":"2019-03-12T16:05:00Z"}

Ergebnisse gruppieren

Verwenden Sie die GROUP BY-Klausel, um die Ergebnisse nach einer oder mehreren Tabellenspalten zu gruppieren. Normalerweise wird eine GROUP BY-Klausel in Verbindung mit einem Aggregatausdruck wie COUNT, SUM und AVG verwendet.

Beispiel 1: Zeigen Sie die Anzahl der Beutel für jede vorgenommene Reservierung an.
SELECT bag.confNo, 
count(bag.bagInfo) AS TOTAL_BAGS 
FROM BaggageInfo bag 
GROUP BY bag.confNo

Erklärung: Jeder Passagier hat einen Reservierungscode (confNo). Ein Passagier kann mehr als ein Gepäckstück haben. Hier gruppieren Sie die Daten basierend auf dem Reservierungscode und Sie erhalten die Anzahl des Arrays bagInfo, das die Anzahl der Gepäckstücke pro Reservierung angibt.

Ausgabe: 
{"confNo":"FH7G1W","TOTAL_BAGS":1}
{"confNo":"PQ1M8N","TOTAL_BAGS":1}
{"confNo":"XT6K7M","TOTAL_BAGS":1}
{"confNo":"DN3I4Q","TOTAL_BAGS":1}
{"confNo":"QB1O0J","TOTAL_BAGS":1}
{"confNo":"TX1P7E","TOTAL_BAGS":1}
{"confNo":"CG6O1M","TOTAL_BAGS":1}
{"confNo":"OH2F8U","TOTAL_BAGS":1}
{"confNo":"BO5G3H","TOTAL_BAGS":1}
{"confNo":"ZG8Z5N","TOTAL_BAGS":1}
{"confNo":"LE6J4Z","TOTAL_BAGS":1}
{"confNo":"XT1O7T","TOTAL_BAGS":1}
{"confNo":"QI3V6Q","TOTAL_BAGS":2}
{"confNo":"RL3J4Q","TOTAL_BAGS":1}
{"confNo":"HJ4J4P","TOTAL_BAGS":1}
{"confNo":"CR2C8MY","TOTAL_BAGS":1}
{"confNo":"LN0C8R","TOTAL_BAGS":1}
{"confNo":"MZ2S5R","TOTAL_BAGS":1}
{"confNo":"KN4D1L","TOTAL_BAGS":1}
{"confNo":"MC0E7R","TOTAL_BAGS":1}
Beispiel 2: Wählen Sie das Gesamtgepäck aus, das von jedem Flughafen (ohne Transitgepäck) stammt. 
SELECT $flt_src as SOURCE, 
count(*) as COUNT 
FROM BaggageInfo $bag, 
$bag.bagInfo.flightLegs[0].fltRouteSrc $flt_src 
GROUP BY $flt_src

Erläuterung: Sie möchten die Gesamtanzahl der Gepäckstücke abrufen, die von jedem Flughafen stammen. Sie möchten jedoch nicht die Flughäfen berücksichtigen, die Teil des Transits sind. Daher gruppieren Sie die Daten mit den Flugquellwerten des ersten Datensatzes des Arrays flightLegs (da der erste Datensatz die Quelle ist). Sie bestimmen dann die Anzahl der Gepäckstücke.

Ausgabe: 
{"SOURCE":"SFO","COUNT":6}
{"SOURCE":"BZN","COUNT":1}
{"SOURCE":"GRU","COUNT":1}
{"SOURCE":"LAX","COUNT":1}
{"SOURCE":"YYZ","COUNT":1}
{"SOURCE":"MEL","COUNT":1}
{"SOURCE":"MIA","COUNT":4}
{"SOURCE":"MSQ","COUNT":2}
{"SOURCE":"MXP","COUNT":2}
{"SOURCE":"JFK","COUNT":3}

Ergebnisse aggregieren

Verwenden Sie die integrierten Aggregat- und Sequence-Aggregatfunktionen, um Informationen wie Anzahl, Summe, Durchschnitt, Minimum oder Maximum zu suchen.

Beispiel 1: Suchen Sie die Gesamtanzahl der aufgegebenen Gepäckstücke, die voraussichtlich zu einem bestimmten Zeitpunkt am LAX-Flughafen ankommen.
SELECT $estdate as ARRIVALDATE, 
count($flight) AS COUNT
FROM BaggageInfo $bag, 
$bag.bagInfo.flightLegs.estimatedArrival $estdate,
$bag.bagInfo.flightLegs.flightNo $flight,  
$bag.bagInfo.flightLegs.fltRouteDest $flt_dest 
WHERE $estdate =any "2019-02-01T11:00:00Z" AND $flt_dest =any "LAX"
GROUP BY $estdate

Erläuterung: In einer Anwendung zur Gepäckverfolgung einer Fluggesellschaft können Sie die Gesamtanzahl der aufgegebenen Gepäckstücke abrufen, die voraussichtlich an einem bestimmten Flughafen und zu einer bestimmten Uhrzeit ankommen. Für jede Flugstrecke enthält das Feld estimatedArrival im Array flightLegs der Tabelle BaggageInfo die Ankunftszeit der aufgegebenen Gepäckstücke und das Feld fltRouteDest den Zielflughafencode. Um in der obigen Abfrage die Gesamtanzahl der aufgegebenen Gepäckstücke zu einem bestimmten Zeitpunkt am LAX-Flughafen zu ermitteln, gruppieren Sie die Daten zunächst mit dem geschätzten Ankunftszeitwert unter Verwendung der GROUP BY-Klausel. Aus der Gruppe wählen Sie nur die Zeilen aus, die den Zielflughafen als LAX aufweisen. Anschließend bestimmen Sie die Beutelanzahl für die resultierenden Zeilen mit der Zählfunktion.

Hier können Sie die Datumsangaben im Zeichenfolgenformat im ISO-8601-Format aufgrund der natürlichen Sortierreihenfolge von Zeichenfolgen vergleichen, ohne sie in Zeitstempel-Datentypen umwandeln zu müssen. $bag.bagInfo.flightLegs.estimatedArrival und $bag.bagInfo.flightLegs.fltRouteDest sind Sequenzen. Da der Vergleichsausdruck '=' nicht für Sequenzen von mehr als einem Element ausgeführt werden kann, wird stattdessen der Sequenzvergleichsoperator '=any' verwendet, um die Felder estimatedArrival und fltRouteDest zu vergleichen.

Ausgabe:
{"ARRIVALDATE":"2019-02-01T11:00:00Z","COUNT":2}
Beispiel 2: Zeigen Sie einem Passagier in der Anwendung zur Gepäckverfolgung der Fluggesellschaft eine automatisierte Nachricht bezüglich der Anzahl der aufgegebenen Gepäckstücke, der Reiseroute und der Fluganzahl an.
SELECT fullName,
b.baginfo[0].routing,
size(baginfo) AS BAGS,
    CASE
        WHEN seq_count(b.bagInfo[0].flightLegs.flightNo) = 1
        THEN "You have one flight to catch"
        WHEN seq_count(b.bagInfo[0].flightLegs.flightNo) = 2
        THEN "You have two flights to catch"
        WHEN seq_count(b.bagInfo[0].flightLegs.flightNo) = 3
        THEN "You have three flights to catch"
        ELSE "You do not have any travel listed today"
    END AS FlightInfo
FROM BaggageInfo b
WHERE ticketNo = 1762320369957

Erläuterung: In der Anwendung zur Gepäckverfolgung der Fluggesellschaft ist es hilfreich, eine kurze Suchmeldung zur Fluganzahl, Anzahl der aufgegebenen Gepäckstücke und Routingdetails einer bevorstehenden Reise für einen Passagier anzuzeigen. Das Array bagInfo enthält die Details des aufgegebenen Beutels des Passagiers. Die Größe des Arrays bagInfo bestimmt die Anzahl der aufgegebenen Gepäckstücke pro Passagier. Das Array flightLegs in der bagInfo enthält die Flugdetails, die den einzelnen Reiseabschnitten entsprechen. Das Routingfeld enthält die Flughafencodes aller Reisefragmente. Sie können die Anzahl der Flüge bestimmen, indem Sie die Felder flightNo im Array flightLegs zählen. Wenn ein Passagier mehr als ein aufgegebenes Gepäckstück hat, gibt es mehr als ein Element im Array bagInfo, eines für jedes Gepäckstück. In solchen Fällen enthält das Array flightLegs in allen Elementen des Feldes bagInfo der Passagierdaten dieselben Werte. Dies liegt daran, dass das Ziel aller aufgegebenen Gepäckstücke für einen Passagier das gleiche ist. Beim Zählen der Felder flightNo dürfen Sie nur ein Element des Arrays bagInfo berücksichtigen, um eine Duplizierung der Ergebnisse zu vermeiden. In dieser Abfrage betrachten Sie nur das erste Element, das heißt bagInfo[0]. Da das Array flightLegs ein Feld flightNo für jedes Reisefragment enthält, handelt es sich um eine Sequenz, und Sie bestimmen die Anzahl der flightNo-Felder pro Passagier mit der Funktion seq_count.

Mit der CASE-Anweisung können Sie verschiedene Meldungen basierend auf der Fluganzahl einführen. Aus Gründen der Benutzerfreundlichkeit werden in der Abfrage nur drei Übertragungen berücksichtigt.

Ausgabe:
{"fullName":"Lorenzo Phil","routing":"SFO/IST/ATH/JTR","BAGS":2,"FlightInfo":"You have three flights to catch"}

Beispiele für die Verwendung der QueryRequest-API

Mit der QueryRequest -API können Sie Daten gruppieren und sortieren sowie aus einer NoSQL-Tabelle abrufen.

Zum Ausführen der Abfrage verwenden Sie die NoSQLHandle.query()-API.

Laden Sie den vollständigen Code GroupSortData.java aus den Beispielen hier herunter.
 //Fetch rows from the table
private static void fetchRows(NoSQLHandle handle,String sqlstmt) throws Exception {
   try (
      QueryRequest queryRequest = new QueryRequest().setStatement(sqlstmt);
      QueryIterableResult results = handle.queryIterable(queryRequest)){
      for (MapValue res : results) {
         System.out.println("\t" + res);
      }
   }
} 
String orderby_stmt="SELECT bag.fullName, bag.bagInfo[].tagNum,bag.bagInfo[].lastSeenTimeGmt FROM BaggageInfo bag "+
                             "WHERE bag.bagInfo[].lastSeenStation=any \"MEL\" ORDER BY bag.bagInfo[].lastSeenTimeGmt DESC";
System.out.println("Using ORDER BY to sort data ");
fetchRows(handle,orderby_stmt);
String sortlimit_stmt="SELECT $bag.fullName, $bag.bagInfo.tagNum, $flt_time FROM BaggageInfo $bag, "+
                       "$bag.bagInfo[].lastSeenTimeGmt $flt_time WHERE $bag.bagInfo[].lastSeenStation=any \"JTR\""+
                       "ORDER BY $flt_time LIMIT 4";
System.out.println("Using ORDER BY and LIMIT to sort and limit data ");
fetchRows(handle,sortlimit_stmt);
String groupsortlimit_stmt="SELECT $flt_src as SOURCE,count(*) as COUNT FROM BaggageInfo $bag, "+
                           "$bag.bagInfo.flightLegs[0].fltRouteSrc $flt_src GROUP BY $flt_src";
System.out.println("Using GROUP BY, ORDER BY and LIMIT to group, sort and limit data ");
fetchRows(handle,groupsortlimit_stmt);

Um die Abfrage auszuführen, verwenden Sie die Methode borneo.NoSQLHandle.query().

Laden Sie den vollständigen Code GroupSortData.py aus den Beispielen hier herunter.
# Fetch data from the table
def fetch_data(handle,sqlstmt):
   request = QueryRequest().set_statement(sqlstmt)
   print('Query results for: ' + sqlstmt)
   result = handle.query(request)
   for r in result.get_results():
      print('\t' + str(r))  
orderby_stmt = '''SELECT bag.fullName, bag.bagInfo[].tagNum,bag.bagInfo[].lastSeenTimeGmt FROM BaggageInfo bag
                     WHERE bag.bagInfo[].lastSeenStation=any \"MEL\" ORDER BY bag.bagInfo[].lastSeenTimeGmt DESC'''
print('Using ORDER BY to sort data:')
fetch_data(handle,orderby_stmt)

sortlimit_stmt = '''SELECT $bag.fullName, $bag.bagInfo.tagNum, $flt_time FROM BaggageInfo $bag,
                    $bag.bagInfo[].lastSeenTimeGmt $flt_time
                    WHERE $bag.bagInfo[].lastSeenStation=any "JTR"
                    ORDER BY $flt_time LIMIT 4'''
print('Using ORDER BY and LIMIT to sort and limit data:')
fetch_data(handle,sortlimit_stmt)

groupsortlimit_stmt = '''SELECT $flt_src as SOURCE, count(*) as COUNT FROM BaggageInfo $bag,
                         $bag.bagInfo.flightLegs[0].fltRouteSrc $flt_src GROUP BY $flt_src'''
print('Using GROUP BY, ORDER BY and LIMIT to group, sort and limit data:')
fetch_data(handle,groupsortlimit_stmt)

Um eine Abfrage auszuführen, verwenden Sie die Funktion Client.Query.

Laden Sie den vollständigen Code GroupSortData.go aus den Beispielen hier herunter.
 //fetch data from the table
func fetchData(client *nosqldb.Client, err error, tableName string, querystmt string)(){
   prepReq := &nosqldb.PrepareRequest{
		Statement: querystmt,
   }
   prepRes, err := client.Prepare(prepReq)
   if err != nil {
      fmt.Printf("Prepare failed: %v\n", err)
      return
   }
   queryReq := &nosqldb.QueryRequest{
		 PreparedStatement: &prepRes.PreparedStatement,   }
   var results []*types.MapValue
   for {
      queryRes, err := client.Query(queryReq)
      if err != nil {
         fmt.Printf("Query failed: %v\n", err)
  	return
      }
      res, err := queryRes.GetResults()
      if err != nil {
         fmt.Printf("GetResults() failed: %v\n", err)
  	return
      }
      results = append(results, res...)
      if queryReq.IsDone() {
         break
      }
   }
   for i, r := range results {
      fmt.Printf("\t%d: %s\n", i+1, jsonutil.AsJSON(r.Map()))
   }
} 
orderby_stmt := `SELECT bag.fullName, bag.bagInfo[].tagNum,bag.bagInfo[].lastSeenTimeGmt FROM BaggageInfo bag
                    WHERE bag.bagInfo[].lastSeenStation=any "MEL" ORDER BY bag.bagInfo[].lastSeenTimeGmt DESC`
fmt.Printf("Using ORDER BY to sort data::\n")
fetchData(client, err,tableName,orderby_stmt)

sortlimit_stmt := `SELECT $bag.fullName, $bag.bagInfo.tagNum, $flt_time FROM BaggageInfo $bag,
                   $bag.bagInfo[].lastSeenTimeGmt $flt_time
                   WHERE $bag.bagInfo[].lastSeenStation=any "JTR"
                   ORDER BY $flt_time LIMIT 4`
fmt.Printf("Using ORDER BY and LIMIT to sort and limit data::\n")
fetchData(client, err,tableName,sortlimit_stmt)

groupsortlimit_stmt := `SELECT $flt_src as SOURCE, count(*) as COUNT FROM BaggageInfo $bag,
                        $bag.bagInfo.flightLegs[0].fltRouteSrc $flt_src GROUP BY $flt_src`
fmt.Printf("Using GROUP BY, ORDER BY and LIMIT to group, sort and limit data::\n")
fetchData(client, err,tableName,groupsortlimit_stmt)

Um eine Abfrage auszuführen, verwenden Sie die Methode query.

JavaScript: Laden Sie den vollständigen Code GroupSortData.js aus den Beispielen hier herunter.
  //fetches data from the table
async function fetchData(handle,querystmt) {
   const opt = {};
   try {
      do {
         const result = await handle.query(querystmt, opt);
         for(let row of result.rows) {
            console.log('  %O', row);
         }
         opt.continuationKey = result.continuationKey;
      } while(opt.continuationKey);
   } catch(error) {
      console.error('  Error: ' + error.message);
   }
}
TypeScript: Laden Sie den vollständigen Code GroupSortData.ts aus den Beispielen hier herunter.
interface StreamInt {
   acct_Id: Integer;
   profile_name: String;
   account_expiry: TIMESTAMP;
   acct_data: JSON;
}
/* fetches data from the table */
async function fetchData(handle: NoSQLClient,querystmt: string) {
   const opt = {};
   try {
      do {
         const result = await handle.query<StreamInt>(querystmt, opt);
         for(let row of result.rows) {
            console.log('  %O', row);
         }
         opt.continuationKey = result.continuationKey;
      } while(opt.continuationKey);
   } catch(error) {
      console.error('  Error: ' + error.message);
   }
}

const orderby_stmt = `SELECT bag.fullName, bag.bagInfo[].tagNum,bag.bagInfo[].lastSeenTimeGmt FROM BaggageInfo bag
                      WHERE bag.bagInfo[].lastSeenStation=any \"MEL\" ORDER BY bag.bagInfo[].lastSeenTimeGmt DESC`
console.log("Using ORDER BY to sort data");
await fetchData(handle,orderby_stmt);

const sortlimit_stmt = `SELECT $bag.fullName, $bag.bagInfo.tagNum, $flt_time FROM BaggageInfo $bag,
                        $bag.bagInfo[].lastSeenTimeGmt $flt_time
                        WHERE $bag.bagInfo[].lastSeenStation=any "JTR"
                        ORDER BY $flt_time LIMIT 4`
console.log("Using ORDER BY and LIMIT to sort and limit data");
await fetchData(handle,sortlimit_stmt);

const groupsortlimit_stmt = `SELECT $flt_src as SOURCE, count(*) as COUNT FROM BaggageInfo $bag,
                             $bag.bagInfo.flightLegs[0].fltRouteSrc $flt_src GROUP BY $flt_src`
console.log("Using GROUP BY, ORDER BY and LIMIT to group, sort and limit data");
await fetchData(handle,groupsortlimit_stmt);

Um eine Abfrage auszuführen, können Sie die Methode QueryAsync aufrufen oder die Methode GetQueryAsyncEnumerable aufrufen und über die resultierende asynchrone Aufzählung iterieren.

Laden Sie den vollständigen Code GroupSortData.cs aus den Beispielen hier herunter.
private static async Task fetchData(NoSQLClient client,String querystmt){
   var queryEnumerable = client.GetQueryAsyncEnumerable(querystmt);
   await DoQuery(queryEnumerable);
}

private static async Task DoQuery(IAsyncEnumerable<QueryResult<RecordValue>> queryEnumerable){
   Console.WriteLine("  Query results:");
   await foreach (var result in queryEnumerable) {
      foreach (var row in result.Rows)
      {
         Console.WriteLine();
         Console.WriteLine(row.ToJsonString());
      }
   }
} 
private const string orderby_stmt =@"SELECT bag.fullName, bag.bagInfo[].tagNum,bag.bagInfo[].lastSeenTimeGmt 
                                             FROM BaggageInfo bag WHERE bag.bagInfo[].lastSeenStation=any ""MEL"" 
                                             ORDER BY bag.bagInfo[].lastSeenTimeGmt DESC";
Console.WriteLine("\nUsing ORDER BY to sort data!");
await fetchData(client,orderby_stmt);

private const string sortlimit_stmt =@"SELECT $bag.fullName, $bag.bagInfo.tagNum, $flt_time FROM BaggageInfo $bag,
                                             $bag.bagInfo[].lastSeenTimeGmt $flt_time
                                             WHERE $bag.bagInfo[].lastSeenStation=any ""JTR""
                                             ORDER BY $flt_time LIMIT 4";
Console.WriteLine("\nUsing ORDER BY and LIMIT to sort and limit data!");
await fetchData(client,sortlimit_stmt);


private const string groupsortlimit_stmt =@"SELECT $flt_src as SOURCE, count(*) as COUNT FROM BaggageInfo $bag,
                                                  $bag.bagInfo.flightLegs[0].fltRouteSrc $flt_src GROUP BY $flt_src" ;
Console.WriteLine("\nUsing GROUP BY, ORDER BY and LIMIT to group, sort and limit data:");
await fetchData(client,groupsortlimit_stmt);