Classificando os Dados de Grupo e de Limitação

Se quiser acompanhar os exemplos, consulte para exibir dados de amostra e usar os scripts para carregar dados de amostra para teste. Os scripts criam as tabelas usadas nos exemplos e carregam dados nas tabelas.

Se quiser seguir os exemplos, consulte Dados de amostra para executar consultas para exibir uma amostra de dados e aprender a usar a console do OCI para criar as tabelas de exemplo e carregar dados usando arquivos JSON.

Tópicos Relacionados

Resultados da prescrição

Use a cláusula ORDER BY para ordenar os resultados por qualquer coluna, chave primária ou chave não primária.

Exemplo 1: Classifique o número do ticket de todos os passageiros pelo nome completo.
SELECT bag.ticketNo, bag.fullName 
FROM BaggageInfo bag 
ORDER BY bag.fullName

Explicação: Você está classificando o número do ticket de passageiros no esquema BaggageInfo com base no nome completo dos passageiros em ordem crescente.

Saída: 
{"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"}
Exemplo 2: Extraia os detalhes do passageiro (nome completo, número da etiqueta) pela última vez (mais recente primeiro) para passageiros (classificados pelo nome) cuja última estação vista é 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
Explicação: Primeiro, filtre os dados na tabela BaggageInfo com base na última estação vista e classifique os resultados filtrados com base na última hora vista e no nome completo dos passageiros em ordem decrescente. Você faz isso usando a cláusula ORDER BY.

Observação:

Você pode usar mais de uma coluna para classificar a saída da consulta.
Saída: 
{"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"}

Limitar e compensar resultados

Use a cláusula LIMIT para limitar o número de resultados retornados de uma instrução SELECT. Por exemplo, se houver 1000 linhas em uma tabela, limite o número de linhas a serem retornadas especificando um valor LIMIT. É recomendável usar LIMIT e OFFSET com uma cláusula ORDER BY. Caso contrário, os resultados serão retornados em uma ordem aleatória, produzindo resultados imprevisíveis.

Um bom caso de uso / exemplo de uso de LIMIT e OFFSET é a paginação de aplicativos de resultados. Digamos, por exemplo, que seu aplicativo queira mostrar 4 resultados por página. Você pode usar limite e deslocamento para implementar paginação sem monitoramento de estado no aplicativo. Se você estiver mostrando n (digamos 4 ) resultados por página, então os resultados da página m (digamos 2) estão sendo exibidos, então o deslocamento seria (n*m-1) que é 4 neste exemplo e o limite seria n (que é 4 aqui).

Exemplo 1: Seu aplicativo pode mostrar 4 resultados em uma página. Extraia os detalhes obtidos por seu aplicativo na primeira página para passageiros cuja última estação vista é 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

Explicação: Você filtra os dados na tabela BaggageInfo com base na última estação vista e classifica o resultado com base na última hora vista. Você usa uma matriz de unnest para nivelar seus dados. Esse é o array bagInfo nivelado e o último horário visto é extraído. Você precisa apenas exibir as primeiras 4 linhas do conjunto de resultados.

Saída:
{"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"}
Exemplo 2: Seu aplicativo pode mostrar 4 resultados em uma página. Extraia os detalhes obtidos por seu aplicativo na segunda página para passageiros cuja última estação vista é 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

Explicação: Você filtra os dados na tabela BaggageInfo com base na última estação vista e classifica o resultado com base na última hora vista. Você usa uma matriz de unnest para nivelar seus dados. Você precisa exibir o conteúdo da segunda página, então você define um OFFSET 4. Embora você LIMITE a 4 linhas, somente uma linha é exibida, pois o conjunto total de resultados é apenas 5. Os primeiros são ignorados e o quinto é exibido.

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

Agrupando resultados

Use a cláusula GROUP BY para agrupar os resultados por uma ou mais colunas de tabela. Normalmente, uma cláusula GROUP BY é usada em conjunto com uma expressão agregada, como COUNT, SUM e AVG.

Exemplo 1: Exibe o número de malas para cada reserva feita.
SELECT bag.confNo, 
count(bag.bagInfo) AS TOTAL_BAGS 
FROM BaggageInfo bag 
GROUP BY bag.confNo

Explicação: Cada passageiro tem um código de reserva (confNo). Um passageiro pode ter mais de uma bagagem. Aqui você agrupa os dados com base no código de reserva e obtém a contagem do array bagInfo, que fornece o número de malas por reserva.

Saída: 
{"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}
Exemplo 2: Selecione a bagagem total proveniente de cada aeroporto (excluindo a bagagem de trânsito). 
SELECT $flt_src as SOURCE, 
count(*) as COUNT 
FROM BaggageInfo $bag, 
$bag.bagInfo.flightLegs[0].fltRouteSrc $flt_src 
GROUP BY $flt_src

Explicação: Você deseja obter a contagem total de bagagem proveniente de cada aeroporto. No entanto, você não quer considerar os aeroportos que fazem parte do trânsito. Portanto, você agrupa os dados com os valores de origem de voo do primeiro registro do array flightLegs (já que o primeiro registro é a origem). Determine a contagem de bagagem.

Saída: 
{"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}

Agregando resultados

Use as funções agregadas incorporadas e agregadas de sequência para localizar informações como uma contagem, uma soma, uma média, um mínimo ou um máximo.

Exemplo 1: Localize o número total de malas despachadas que são estimadas para chegar ao aeroporto LAX em um determinado momento.
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

Explicação: Em um aplicativo de rastreamento de bagagem de companhia aérea, você pode obter a contagem total de malas despachadas estimadas para chegar a um determinado aeroporto e horário. Para cada trecho de voo, o campo estimatedArrival no array flightLegs da tabela BaggageInfo contém a hora de chegada das malas despachadas e o campo fltRouteDest contém o código do aeroporto de destino. Na consulta acima, para determinar o número total de malas despachadas que chegam ao aeroporto LAX em um determinado momento, primeiro agrupe os dados com o valor estimado da hora de chegada usando a cláusula GROUP BY. No grupo, você seleciona apenas as linhas que têm o aeroporto de destino como LAX. Em seguida, determine a contagem de bolsas para as linhas resultantes usando a função de contagem.

Aqui, você pode comparar as datas formatadas em string no formato ISO-8601 devido à ordem de classificação natural das strings sem precisar convertê-las em tipos de dados de timestamp. $bag.bagInfo.flightLegs.estimatedArrival e $bag.bagInfo.flightLegs.fltRouteDest são sequências. Como a expressão de comparação '=' não pode operar em sequências de mais de um item, o operador de comparação de sequência '=any' é usado para comparar os campos estimatedArrival e fltRouteDest.

Saída:
{"ARRIVALDATE":"2019-02-01T11:00:00Z","COUNT":2}
Exemplo 2: exiba uma mensagem automatizada sobre o número de malas despachadas, rota de viagem e contagem de voos para um passageiro no aplicativo de rastreamento de bagagem de companhia aérea.
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

Explicação: No aplicativo de rastreamento de bagagem de companhia aérea, é útil exibir uma mensagem de consulta rápida sobre a contagem de voos, o número de malas despachadas e os detalhes de roteamento de uma próxima viagem de um passageiro. O array bagInfo contém os detalhes da mala despachada do passageiro. O tamanho do array bagInfo determina o número de malas despachadas por passageiro. O array flightLegs no bagInfo inclui os detalhes do voo correspondentes a cada trecho de viagem. O campo de roteamento inclui os códigos de aeroporto de todos os fragmentos de viagem. Você pode determinar o número de voos contando os campos flightNo no array flightLegs. Se um passageiro tiver mais de uma mala despachada, haverá mais de um elemento no array bagInfo, um para cada mala. Nesses casos, o array flightLegs em todos os elementos do campo bagInfo de dados de um passageiro conterá os mesmos valores. Isso ocorre porque o destino de todas as malas despachadas de um passageiro será o mesmo. Ao contar os campos flightNo, você deve considerar apenas um elemento do array bagInfo para evitar a duplicação de resultados. Nesta consulta, você considera apenas o primeiro elemento, ou seja, bagInfo[0]. Como o array flightLegs tem um campo flightNo para cada fragmento de deslocamento, ele é uma sequência e você determina a contagem dos campos flightNo por passageiro usando a função seq_count.

Use a instrução CASE para introduzir mensagens diferentes com base na contagem de voos. Para facilitar o uso, apenas três trânsitos são considerados na consulta.

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

Exemplos usando a API QueryRequest

Você pode usar a API QueryRequest para agrupar e ordenar dados e também extraí-los de uma tabela NoSQL.

Para executar sua consulta, use a API NoSQLHandle.query().

Faça download do código completo GroupSortData.java nos exemplos aqui.
 //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);

Para executar sua consulta, use o método borneo.NoSQLHandle.query().

Faça download do código completo GroupSortData.py nos exemplos aqui.
# 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)

Para executar uma consulta, use a função Client.Query.

Faça download do código completo GroupSortData.go nos exemplos aqui.
 //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)

Para executar uma consulta, use o método query.

JavaScript: Faça download do código completo GroupSortData.js nos exemplos aqui.
  //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: Faça download do código completo GroupSortData.ts nos exemplos aqui.
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);

Para executar uma consulta, você pode chamar o método QueryAsync ou chamar o método GetQueryAsyncEnumerable e iterar sobre o enumerável assíncrono resultante.

Faça download do código completo GroupSortData.cs nos exemplos aqui.
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);