Trier le regroupement et limiter les données

Si vous souhaitez suivre les exemples, reportez-vous à la section pour afficher un exemple de données et utiliser les scripts pour charger des exemples de données à des fins de test. Les scripts créent les tables utilisées dans les exemples et chargent les données dans les tables.

Si vous voulez suivre les exemples, reportez-vous à Exemples de données pour exécuter des requêtes afin de visualiser un exemple de données et d'apprendre à utiliser la console OCI pour créer les exemples de tables et charger des données à l'aide de fichiers JSON.

Rubriques connexes

Tri des résultats

Utilisez la clause ORDER BY pour trier des résultats par colonne, clé primaire ou clé secondaire.

Exemple 1 : Triez le numéro de billet de tous les passagers en fonction de leur nom complet.
SELECT bag.ticketNo, bag.fullName 
FROM BaggageInfo bag 
ORDER BY bag.fullName

Explication : Vous triez le numéro de ticket des passagers dans le schéma BaggageInfo en fonction du nom complet des passagers dans l'ordre croissant.

Sortie : 
{"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"}
Exemple 2 : Extrayez les détails du passager (nom complet, numéro d'étiquette) en fonction de la dernière heure de consultation (la dernière en premier) pour les passagers (triés par leur nom) dont la dernière station vue est MEL.
SELECT bag.fullName, bag.bagInfo[].tagNum, 
bag.bagInfo[].lastSeenTimeGmt
FROM BaggageInfo bag 
WHERE bag.bagInfo[].lastSeenStation=any "MEL"
ORDER BY bag.bagInfo[].lastSeenTimeGmt DESC
Explication : Vous commencez par filtrer les données du tableau BaggageInfo en fonction de la dernière station vue et vous triez les résultats filtrés en fonction de la dernière heure vue et du nom complet des passagers par ordre décroissant. Pour ce faire, utilisez la clause ORDER BY.

Remarques :

Vous pouvez utiliser plusieurs colonnes pour trier le résultat de la requête.
Sortie : 
{"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"}

Limitation et décalage des résultats

Utilisez la clause LIMIT pour limiter le nombre de résultats renvoyés par une instruction SELECT. Par exemple, si une table contient 1000 lignes, limitez le nombre de lignes à renvoyer en indiquant une valeur LIMIT. Il est recommandé d'utiliser LIMIT et OFFSET avec une clause ORDER BY. Sinon, les résultats sont renvoyés dans un ordre aléatoire, produisant des résultats imprévisibles.

Un bon cas d'utilisation / exemple d'utilisation de LIMIT et OFFSET est la pagination d'application des résultats. Supposons par exemple que votre application souhaite afficher 4 résultats par page. Vous pouvez utiliser une limite et un décalage pour implémenter la pagination sans conservation de statut dans l'application. Si vous affichez n ( disons 4 ) résultats par page, alors les résultats de la page m ( disons 2) sont affichés, alors le décalage serait (n*m-1) qui est 4 dans cet exemple et la limite serait n(qui est 4 ici).

Exemple 1 : Votre application peut afficher 4 résultats sur une page. Extrayez les détails extraits par votre application sur la première page pour les passagers dont la dernière station vue est JTR.
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

Explication : Vous filtrez les données du tableau BaggageInfo en fonction de la dernière station vue et vous triez le résultat en fonction de la dernière heure vue. Vous utilisez un tableau non test pour aplatir vos données. C'est-à-dire que le tableau bagInfo est mis à plat et que la dernière heure vue est extraite. Vous devez simplement afficher les 4 premières lignes de l'ensemble de résultats.

Sortie :
{"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"}
Exemple 2 : votre application peut afficher 4 résultats sur une page. Extrayez les détails extraits par votre application sur la deuxième page pour les passagers dont la dernière station vue est JTR.
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

Explication : Vous filtrez les données du tableau BaggageInfo en fonction de la dernière station vue et vous triez le résultat en fonction de la dernière heure vue. Vous utilisez un tableau non test pour aplatir vos données. Vous devez afficher le contenu de la deuxième page afin de définir un OFFSET 4. Bien que vous LIMITEZ à 4 lignes, une seule ligne s'affiche car l'ensemble de résultats total n'est que de 5. Les premiers sont ignorés et le cinquième est affiché.

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

Regroupement des résultats

Utilisez la clause GROUP BY pour regrouper les résultats en fonction de colonnes de table. En règle générale, une clause GROUP BY est utilisée conjointement avec une expression d'agrégation telle que COUNT, SUM et AVG.

Exemple 1 : affiche le nombre de sacs pour chaque réservation effectuée.
SELECT bag.confNo, 
count(bag.bagInfo) AS TOTAL_BAGS 
FROM BaggageInfo bag 
GROUP BY bag.confNo

Explication : chaque passager a un code de réservation (confNo). Un passager peut avoir plus d'un bagage. Ici, vous regroupez les données en fonction du code de réservation et vous obtenez le nombre du tableau bagInfo qui donne le nombre de sacs par réservation.

Sortie : 
{"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}
Exemple 2 : Sélectionnez le total des bagages provenant de chaque aéroport (à l'exception des bagages de transit). 
SELECT $flt_src as SOURCE, 
count(*) as COUNT 
FROM BaggageInfo $bag, 
$bag.bagInfo.flightLegs[0].fltRouteSrc $flt_src 
GROUP BY $flt_src

Explication : Vous voulez obtenir le nombre total de bagages provenant de chaque aéroport. Cependant, vous ne voulez pas considérer les aéroports qui font partie du transit. Vous regroupez donc les données avec les valeurs de source de vol du premier enregistrement du tableau flightLegs (le premier enregistrement étant la source). Vous déterminez ensuite le nombre de bagages.

Sortie : 
{"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}

Agrégation des résultats

Utilisez les fonctions d'agrégation et de séquence intégrées pour rechercher des informations telles qu'un nombre, une somme, une moyenne, un minimum ou un maximum.

Exemple 1 : Permet de rechercher le nombre total de bagages enregistrés qui sont estimés arriver à l'aéroport LAX à un moment donné.
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

Explication : Dans une application de suivi des bagages d'une compagnie aérienne, vous pouvez obtenir le nombre total de bagages enregistrés qui sont estimés arriver à un aéroport et une heure donnés. Pour chaque étape de vol, le champ estimatedArrival du tableau flightLegs de la table BaggageInfo contient l'heure d'arrivée des bagages enregistrés et le champ fltRouteDest contient le code de l'aéroport de destination. Dans la requête ci-dessus, pour déterminer le nombre total de bagages enregistrés arrivant à l'aéroport LAX à un moment donné, vous devez d'abord regrouper les données avec la valeur d'heure d'arrivée estimée à l'aide de la clause GROUP BY. Dans le groupe, sélectionnez uniquement les lignes pour lesquelles l'aéroport de destination est LAX. Vous déterminez ensuite le nombre de poches pour les lignes résultantes à l'aide de la fonction de comptage.

Ici, vous pouvez comparer les dates au format chaîne au format ISO-8601 en raison de l'ordre de tri naturel des chaînes sans avoir à les convertir en types de données d'horodatage. $bag.bagInfo.flightLegs.estimatedArrival et $bag.bagInfo.flightLegs.fltRouteDest sont des séquences. Etant donné que l'expression de comparaison '=' ne peut pas fonctionner sur des séquences de plusieurs éléments, l'opérateur de comparaison de séquences '=any' est utilisé à la place pour comparer les champs estimatedArrival et fltRouteDest.

Sortie :
{"ARRIVALDATE":"2019-02-01T11:00:00Z","COUNT":2}
Exemple 2 : Affiche un message automatisé concernant le nombre de bagages enregistrés, l'itinéraire de voyage et le nombre de vols vers un passager dans l'application de suivi des bagages de la compagnie aérienne.
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

Explication : Dans l'application de suivi des bagages de la compagnie aérienne, il est utile d'afficher un message de recherche rapide concernant le nombre de vols, le nombre de bagages enregistrés et les détails d'acheminement d'un voyage à venir pour un passager. Le tableau bagInfo contient les détails des bagages enregistrés du passager. La taille du tableau bagInfo détermine le nombre de bagages enregistrés par passager. Le tableau flightLegs dans bagInfo inclut les détails de vol correspondant à chaque étape de déplacement. Le champ de routage inclut les codes aéroport de tous les fragments de trajet. Vous pouvez déterminer le nombre de vols en comptant les champs flightNo dans le tableau flightLegs. Si un passager a plusieurs bagages enregistrés, il y aura plus d'un élément dans le tableau bagInfo, un pour chaque sac. Dans ce cas, le tableau flightLegs de tous les éléments du champ bagInfo des données passagers contiendra les mêmes valeurs. En effet, la destination de tous les bagages enregistrés pour un passager sera la même. Lors du comptage des champs flightNo, vous devez prendre en compte un seul élément du tableau bagInfo pour éviter la duplication des résultats. Dans cette requête, vous ne prenez en compte que le premier élément, à savoir bagInfo[0]. Comme le tableau flightLegs comporte un champ flightNo pour chaque fragment de déplacement, il s'agit d'une séquence et vous déterminez le nombre de champs flightNo par passager à l'aide de la fonction seq_count.

Utilisez l'instruction CASE pour introduire différents messages en fonction du nombre de vols. Pour faciliter l'utilisation, seuls trois transits sont pris en compte dans la requête.

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

Exemples d'utilisation de l'API QueryRequest

Vous pouvez utiliser l'API QueryRequest pour regrouper et trier les données, ainsi que pour les extraire d'une table NoSQL.

Pour exécuter la requête, utilisez l'API NoSQLHandle.query().

Téléchargez le code complet GroupSortData.java à partir des exemples ici.
 //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);

Pour exécuter votre requête, utilisez la méthode borneo.NoSQLHandle.query().

Téléchargez le code complet GroupSortData.py à partir des exemples ici.
# 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)

Pour exécuter une requête, utilisez la fonction Client.Query.

Téléchargez le code complet GroupSortData.go à partir des exemples ici.
 //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)

Pour exécuter une requête, utilisez la méthode query.

JavaScript : téléchargez le code complet GroupSortData.js à partir des exemples ici.
  //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 : téléchargez le code complet GroupSortData.ts à partir des exemples ici.
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);

Pour exécuter une requête, vous pouvez appeler la méthode QueryAsync ou appeler la méthode GetQueryAsyncEnumerable et effectuer une itération sur l'énumérable asynchrone résultant.

Téléchargez le code complet GroupSortData.cs à partir des exemples ici.
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);