Uso delle funzioni Timestamp nelle query

È possibile eseguire varie operazioni aritmetiche sui valori di indicatore orario e durata.

Se si desidera seguire gli esempi, vedere per visualizzare i dati di esempio e utilizzare gli script per caricare i dati di esempio per i test. Gli script creano le tabelle utilizzate negli esempi e caricano i dati nelle tabelle.

Se si desidera seguire gli esempi, vedere Dati di esempio per eseguire query per visualizzare dati di esempio e imparare a utilizzare OCI Console per creare le tabelle di esempio e caricare i dati utilizzando i file JSON.

Argomenti correlati

Espressioni Extract

L'espressione EXTRACT estrae un componente da un indicatore orario.
extract_expression ::= EXTRACT "(" id FROM expression ")"

L'espressione dopo la parola chiave FROM deve restituire al massimo un indicatore orario o NULL. Se il risultato di questa espressione è NULL o vuoto, il risultato di EXTRACT è NULL o vuoto, rispettivamente. In caso contrario, viene restituito il componente specificato dall'ID. Questo ID deve essere una delle seguenti parole chiave: ANNO, MESE, GIORNO, ORA, MINUTO, SECONDO, MILLISECOND, MICROSECOND, NANOSECOND, SETTIMANA, ISOWEEK.

Esempio 1: nome completo e anno di arrivo del bagaglio per il cliente con numero di biglietto 1762383911861.
SELECT fullName, 
EXTRACT (YEAR FROM CAST (bag.bagInfo.bagArrivalDate AS Timestamp(0)))
AS YEAR FROM BaggageInfo bag 
WHERE ticketNo=1762383911861

Spiegazione: utilizzare innanzitutto CAST per convertire bagArrivalDate in TIMESTAMP e quindi recuperare il componente YEAR dall'indicatore orario.

Output: 
{"fullName":"Joanne Diaz","YEAR":2019}
Esempio 2: recuperare tutte le borse che hanno viaggiato attraverso MIA tra le 10:00 e le 10:00 nel febbraio 2019.
SELECT bag.bagInfo[].tagNum,bag.bagInfo[].flightLegs[].fltRouteSrc,
$t1 AS HOUR FROM BaggageInfo bag,
EXTRACT(HOUR FROM CAST (bag.bagInfo[0].bagArrivalDate AS Timestamp(0))) $t1,
EXTRACT(YEAR FROM CAST (bag.bagInfo[0].bagArrivalDate AS Timestamp(0))) $t2,
EXTRACT(MONTH FROM CAST (bag.bagInfo[0].bagArrivalDate AS Timestamp(0))) $t3
WHERE bag.bagInfo[].flightLegs[].fltRouteSrc=any "MIA" AND
$t2=2019 AND $t3=02 AND ($t1>10 AND $t1<20)

Spiegazione: Vuoi conoscere i dettagli dei voli che hanno attraversato il MIA tra le 10:00 e le 10:00 di febbraio 2019. Qui vengono utilizzate diverse condizioni di filtro. In primo luogo, il volo avrebbe dovuto essere originato o attraversato attraverso MIA. L'anno di arrivo dovrebbe essere 2019 e il mese di arrivo dovrebbe essere 2 (febbraio). Quindi filtra se l'ora di arrivo è compresa tra le 10:00 e le 10:00 (20 ore).

Output: 
{"tagNum":"17657806255240","fltRouteSrc":["MIA","LAX"],"HOUR":16}
{"tagNum":"17657806292518","fltRouteSrc":["MIA","LAX"],"HOUR":16}
Esempio 3: quale anno e quale mese il passeggero con il codice di prenotazione PQ1M8N ha ricevuto il bagaglio?
SELECT fullName, 
EXTRACT(YEAR FROM CAST (bag.bagInfo.bagArrivalDate AS Timestamp(0))) AS YEAR, 
EXTRACT(MONTH FROM CAST (bag.bagInfo.bagArrivalDate AS Timestamp(0))) AS MONTH 
FROM BaggageInfo bag WHERE bag.confNo="PQ1M8N"

Spiegazione: utilizzare innanzitutto CAST per convertire bagArrivalDate in TIMESTAMP e quindi recuperare il componente YEAR e il componente MONTH dall'indicatore orario.

Output:
{"fullName":"Kendal Biddle","YEAR":2019,"MONTH":3}
Esempio 4: raggruppare i dati relativi ai bagagli in base al mese di arrivo e visualizzare il mese e il numero di bagagli arrivati in quel mese.
SELECT EXTRACT(MONTH FROM CAST ($bag_arr_date AS Timestamp(0))) AS MONTH,
count(EXTRACT(MONTH FROM CAST ($bag_arr_date AS Timestamp(0)))) AS COUNT
FROM BaggageInfo $bag, $bag.bagInfo[].bagArrivalDate $bag_arr_date 
GROUP BY EXTRACT(MONTH FROM CAST ($bag_arr_date AS Timestamp(0)))
Spiegazione: si desidera raggruppare i dati in base al mese di arrivo del bagaglio. Utilizzare un array non nido per appiattire i dati. L'array bagInfo viene appiattito e il valore della data di arrivo del sacchetto viene recuperato dall'array. Utilizzare quindi CAST per convertire bagArrivalDate in un TIMESTAMP e quindi recuperare il componente YEAR e il componente MONTH dall'indicatore orario. Quindi si utilizza la funzione count per ottenere il bagaglio totale corrispondente a ogni mese.

Nota

Un presupposto nei dati è che tutto il bagaglio è arrivato nello stesso anno. I dati vengono quindi raggruppati solo in base al mese.
Output:
{"MONTH":2,"COUNT":11}
{"MONTH":3,"COUNT":10}

Funzione timestamp_add()

Aggiunge una durata a un valore di indicatore orario e restituisce il nuovo indicatore orario. La durata può essere positiva o negativa. Il tipo di risultato è TIMESTAMP(9).

Sintassi:
TIMESTAMP(9) timestamp_add(TIMESTAMP timestamp, STRING duration)
Semantica:
  • indicatore orario: un valore TIMESTAMP o un valore che può essere convertito in TIMESTAMP.
  • durata: stringa con formato [-](<n> <UNIT>)+, dove 'n' è un numero e <UNIT> può essere YEAR, MONTH, DAY, HOUR, MINUTE, SECOND, MILLISECOND, NANOSECOND o la forma plurale di queste parole chiave (ad esempio YEARS).

    Nota

    La parola chiave UNIT non fa distinzione tra maiuscole e minuscole.
  • valore di ritorno: TIMESTAMP(9)
Esempio 1: nell'applicazione della compagnia aerea, un buffer di cinque minuti di ritardo viene considerato "in tempo". Stampare l'orario di arrivo stimato sulla prima tappa con un buffer di cinque minuti per il passeggero con il numero di biglietto 1762399766476. 
SELECT timestamp_add(bag.bagInfo.flightLegs[0].estimatedArrival, "5 minutes")
AS ARRIVAL_TIME FROM BaggageInfo bag 
WHERE ticketNo=1762399766476

Spiegazione: nell'applicazione della compagnia aerea, un cliente può avere un numero qualsiasi di tappe del volo a seconda dell'origine e della destinazione. Nella query sopra, si sta recuperando l'arrivo stimato nella "prima tappa" del viaggio. Il primo record dell'array flightsLeg viene quindi recuperato e l'ora estimatedArrival viene recuperata dall'array e viene aggiunto e visualizzato un buffer di "5 minuti".

Output: 
{"ARRIVAL_TIME":"2019-02-03T06:05:00.000000000Z"}

Nota

La colonna estimatedArrival è STRING. Se la colonna contiene valori STRING in formato ISO-8601, verrà convertita automaticamente dal runtime SQL in tipo di dati TIMESTAMP.

ISO8601 descrive un modo accettato a livello internazionale per rappresentare date, orari e durate.

Syntax: Date with time: YYYY-MM-DDThh:mm:ss[.s[s[s[s[s[s]]]]][Z|(+|-)hh:mm]

dove
  • YYYY specifica l'anno come quattro cifre decimali
  • MM specifica il mese, come due cifre decimali, da 00 a 12
  • DD specifica il giorno, come due cifre decimali, da 00 a 31
  • hh specifica l'ora, come due cifre decimali, da 00 a 23
  • mm specifica i minuti, come due cifre decimali, da 00 a 59
  • ss[.s[s[s[s[s]]] specifica i secondi, come due cifre decimali, da 00 a 59, facoltativamente seguiti da una virgola decimale e da 1 a 6 cifre decimali (che rappresentano la parte frazionaria di un secondo).
  • Z specifica l'ora UTC (fuso orario 0). Può essere specificato anche da +00:00, ma non da -00:00.
  • (+|-)hh:mm specifica il fuso orario come differenza da UTC. (È necessario utilizzare + o -).
Esempio 1a: stampare l'ora di arrivo stimata in ogni tappa con un buffer di cinque minuti per il passeggero con il numero di biglietto 1762399766476.
SELECT $s.ticketno, $value as estimate, 
timestamp_add($value, '5 minute') AS add5min
FROM baggageinfo $s,
$s.bagInfo.flightLegs.estimatedArrival as $value
WHERE ticketNo=1762399766476

Spiegazione: si desidera visualizzare l'ora estimatedArrival su ogni tappa. Il numero di gambe può essere diverso per ogni cliente. Pertanto, il riferimento alla variabile viene utilizzato nella query precedente e l'array baggageInfo e l'array flightLegs non sono nidificati per eseguire la query.

Output:
{"ticketno":1762399766476,"estimate":"2019-02-03T06:00:00Z",
"add5min":"2019-02-03T06:05:00.000000000Z"}
{"ticketno":1762399766476,"estimate":"2019-02-03T08:22:00Z",
"add5min":"2019-02-03T08:27:00.000000000Z"}
Esempio 2: numero di borse arrivate nell'ultima settimana
SELECT count(*) AS COUNT_LASTWEEK FROM baggageInfo bag 
WHERE EXISTS bag.bagInfo[$element.bagArrivalDate < current_time()
AND $element.bagArrivalDate > timestamp_add(current_time(), "-7 days")]

Spiegazione: si ottiene un conteggio del numero di borse elaborate dall'applicazione della compagnia aerea nell'ultima settimana. Un cliente può avere più di un sacchetto (l'array bagInfo può avere più di un record). Il valore di bagArrivalDate deve essere compreso tra oggi e gli ultimi 7 giorni. Per ogni record nell'array bagInfo, si determina se l'ora di arrivo del sacchetto è compresa tra l'ora corrente e una settimana fa. La funzione current_time ti dà il tempo ora. Come filtro viene utilizzata una condizione EXISTS per determinare se il sacchetto ha una data di arrivo nell'ultima settimana. La funzione count determina il numero totale di sacchetti in questo periodo di tempo.

Output: 
{"COUNT_LASTWEEK":0}
Esempio 3: trovare il numero di borse che arrivano nelle 6 ore successive.
SELECT count(*) AS COUNT_NEXT6HOURS FROM baggageInfo bag 
WHERE EXISTS bag.bagInfo[$element.bagArrivalDate > current_time()
AND $element.bagArrivalDate < timestamp_add(current_time(), "6 hours")]

Spiegazione: si ottiene un conteggio del numero di borse che verranno elaborate dall'applicazione della compagnia aerea nelle prossime 6 ore. Un cliente può avere più di un sacchetto (l'array bagInfo può avere più di un record). Il valore bagArrivalDate deve essere compreso tra l'ora corrente e le 6 ore successive. Per ogni record nell'array bagInfo, determinare se l'ora di arrivo del sacchetto è compresa tra l'ora corrente e sei ore successive. La funzione current_time ti dà il tempo ora. Come filtro viene utilizzata una condizione EXISTS per determinare se il sacchetto ha una data di arrivo nelle sei ore successive. La funzione count determina il numero totale di sacchetti in questo periodo di tempo.

Output: 
{"COUNT_NEXT6HOURS":0}

Funzioni timestamp_diff() e get_duration()

timestamp_diff()

Restituisce il numero di millisecondi tra due valori di indicatore orario. Il tipo di risultato è LONG.

Sintassi:
LONG timestamp_diff(TIMESTAMP timestamp1, TIMESTAMP
      timestamp2)
Semantica:
  • timestamp1: un valore TIMESTAMP o un valore che può essere convertito in TIMESTAMP
  • timestamp2: un valore TIMESTAMP o un valore che può essere convertito in TIMESTAMP
  • valore restituito: LONG

get_duration()

Converte il numero di millisecondi specificato in una stringa di durata. Il tipo di risultato è STRING.

Sintassi:
STRING get_duration(LONG duration_millis)
Semantica:
  • duration_millis: la durata in millisecondi.
  • valore restituito: STRING. Il formato stringa di durata restituito è [-](<n> <UNIT>)+, dove <UNIT> può essere DAY, HOUR, MINUTE, SECOND e MILLISECOND, ad esempio "1 giorno 2 ore" o "-10 minuti 0 secondo 500 millisecondi".

Esempi:

Esempio 1: qual è la durata tra l'imbarco del bagaglio a una gamba e il raggiungimento della tappa successiva per il passeggero con numero di biglietto 1762355527825? 
SELECT $s.ticketno, $bagInfo.bagArrivalDate, $flightLeg.flightDate,
get_duration(timestamp_diff($bagInfo.bagArrivalDate, $flightLeg.flightDate)) AS diff
FROM baggageinfo $s, 
$s.bagInfo[] AS $bagInfo, $bagInfo.flightLegs[] AS $flightLeg
WHERE ticketNo=1762355527825

Spiegazione: in un'applicazione aerea ogni cliente può disporre di un numero diverso di hop/leg tra l'origine e la destinazione. In questa query si determina il tempo impiegato tra ogni tappa del volo. Ciò è determinato dalla differenza tra bagArrivalDate e flightDate per ogni tappa di volo. Per determinare la durata in giorni, ore o minuti, passare il risultato della funzione timestamp_diff alla funzione get_duration.

Output: 
{"bagArrivalDate":"2019-03-22T10:17:00Z","flightDate":"2019-03-22T07:00:00Z",
"diff":"3 hours 17 minutes"}
{"bagArrivalDate":"2019-03-22T10:17:00Z","flightDate":"2019-03-22T07:23:00Z",
"diff":"2 hours 54 minutes"}
{"bagArrivalDate":"2019-03-22T10:17:00Z","flightDate":"2019-03-22T08:23:00Z",
"diff":"1 hour 54 minutes"}
Per determinare la durata in millisecondi, utilizzare solo la funzione timestamp_diff.
SELECT $s.ticketno, $bagInfo.bagArrivalDate, $flightLeg.flightDate,
timestamp_diff($bagInfo.bagArrivalDate, $flightLeg.flightDate) AS diff
FROM baggageinfo $s, 
$s.bagInfo[] AS $bagInfo, 
$bagInfo.flightLegs[] AS $flightLeg
WHERE ticketNo=1762355527825
Esempio 2: quanto tempo ci vuole dal momento del check-in al momento della scansione del bagaglio nel punto di imbarco per il passeggero con numero di biglietto 176234463813?
SELECT $flightLeg.flightNo,
$flightLeg.actions[contains($element.actionCode, "Checkin")].actionTime AS checkinTime,
$flightLeg.actions[contains($element.actionCode, "BagTag Scan")].actionTime AS bagScanTime,
get_duration(timestamp_diff(
    $flightLeg.actions[contains($element.actionCode, "Checkin")].actionTime,
    $flightLeg.actions[contains($element.actionCode, "BagTag Scan")].actionTime
)) AS diff
FROM baggageinfo $s, 
$s.bagInfo[].flightLegs[] AS $flightLeg
WHERE ticketNo=176234463813 AND 
starts_with($s.bagInfo[].routing, $flightLeg.fltRouteSrc)

Spiegazione: nei dati relativi ai bagagli, ogni flightLeg dispone di un array di azioni. Nell'array di azioni sono presenti tre azioni diverse. Il codice azione per il primo elemento dell'array è Check-in/Offload. Per la prima tappa, il codice azione è Checkin e per le altre tappe, il codice azione è Offload al hop. Il codice azione per il secondo elemento dell'array è BagTag Scan. Nella query precedente è possibile determinare la differenza di tempo di azione tra la scansione dei tag bag e l'ora di check-in. La funzione contains consente di filtrare l'ora dell'azione solo se il codice dell'azione è Check-in o BagScan. Poiché solo la prima tappa di volo dispone di dettagli per il check-in e la scansione dei bagagli, è inoltre possibile filtrare i dati utilizzando la funzione starts_with per recuperare solo il codice sorgente fltRouteSrc. Per determinare la durata in giorni, ore o minuti, passare il risultato della funzione timestamp_diff alla funzione get_duration.

Per determinare la durata in millisecondi, utilizzare solo la funzione timestamp_diff.
SELECT $flightLeg.flightNo,
$flightLeg.actions[contains($element.actionCode, "Checkin")].actionTime AS checkinTime,
$flightLeg.actions[contains($element.actionCode, "BagTag Scan")].actionTime AS bagScanTime,
timestamp_diff(
   $flightLeg.actions[contains($element.actionCode, "Checkin")].actionTime,
   $flightLeg.actions[contains($element.actionCode, "BagTag Scan")].actionTime
) AS diff
FROM baggageinfo $s, 
$s.bagInfo[].flightLegs[] AS $flightLeg
WHERE ticketNo=176234463813 AND 
starts_with($s.bagInfo[].routing, $flightLeg.fltRouteSrc)
Output: 
{"flightNo":"BM572","checkinTime":"2019-03-02T03:28:00Z",
"bagScanTime":"2019-03-02T04:52:00Z","diff":"- 1 hour 24 minutes"}
Esempio 3: quanto tempo ci vuole per i sacchi di un cliente con ticket n. 1762320369957 per raggiungere il primo punto di transito? 
SELECT  $bagInfo.flightLegs[1].actions[2].actionTime,
$bagInfo.flightLegs[0].actions[0].actionTime,
get_duration(timestamp_diff($bagInfo.flightLegs[1].actions[2].actionTime,
                            $bagInfo.flightLegs[0].actions[0].actionTime)) AS diff
FROM baggageinfo $s, $s.bagInfo[] AS $bagInfo     
WHERE ticketNo=1762320369957

Spiegazione: in un'applicazione aerea ogni cliente può disporre di un numero diverso di hop/leg tra l'origine e la destinazione. Nell'esempio precedente, si determina il tempo impiegato per il sacchetto per raggiungere il primo punto di transito. Nei dati relativi ai bagagli, flightLeg è un array. Il primo record dell'array fa riferimento ai dettagli del primo punto di transito. Il valore flightDate nel primo record è l'ora in cui il sacchetto lascia l'origine e il valore estimatedArrival nel primo record della gamba di volo indica l'ora in cui raggiunge il primo punto di transito. La differenza tra i due dà il tempo necessario affinché la borsa raggiunga il primo punto di transito. Per determinare la durata in giorni, ore o minuti, passare il risultato della funzione timestamp_diff alla funzione get_duration.

Per determinare la durata in millisecondi, utilizzare la funzione timestamp_diff. 
SELECT  $bagInfo.flightLegs[0].flightDate,
$bagInfo.flightLegs[0].estimatedArrival,
timestamp_diff($bagInfo.flightLegs[0].estimatedArrival,
             $bagInfo.flightLegs[0].flightDate) AS diff
FROM baggageinfo $s, $s.bagInfo[] AS $bagInfo
WHERE ticketNo=1762320369957
Output: 
{"flightDate":"2019-03-12T03:00:00Z","estimatedArrival":"2019-03-12T16:00:00Z","diff":"13 hours"}
{"flightDate":"2019-03-12T03:00:00Z","estimatedArrival":"2019-03-12T16:40:00Z","diff":"13 hours 40 minutes"}

Esempi di utilizzo dell'API QueryRequest

È possibile utilizzare l'API QueryRequest e applicare le funzioni SQL per recuperare i dati da una tabella NoSQL.

Per eseguire la query, utilizzare l'API NoSQLHandle.query().

Scarica il codice completo SQLFunctions.java dagli esempi qui.
 //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 ts_func1="SELECT timestamp_add(bag.bagInfo.flightLegs[0].estimatedArrival, \"5 minutes\")"+
                         " AS ARRIVAL_TIME FROM BaggageInfo bag WHERE ticketNo=1762341772625";
System.out.println("Using timestamp_add function ");
fetchRows(handle,ts_func1);
String ts_func2="SELECT $s.ticketno, $bagInfo.bagArrivalDate, $flightLeg.flightDate, "+
                "get_duration(timestamp_diff($bagInfo.bagArrivalDate, $flightLeg.flightDate)) AS diff "+
                 "FROM baggageinfo $s, $s.bagInfo[] AS $bagInfo, $bagInfo.flightLegs[] AS $flightLeg "+
                 "WHERE ticketNo=1762344493810";
System.out.println("Using get_duration and timestamp_diff function ");
fetchRows(handle,ts_func2);

Per eseguire la query, utilizzare il metodo borneo.NoSQLHandle.query().

Scarica il codice completo SQLFunctions.py dagli esempi qui.
# 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))  
 ts_func1 = '''SELECT timestamp_add(bag.bagInfo.flightLegs[0].estimatedArrival, "5 minutes")
                 AS ARRIVAL_TIME FROM BaggageInfo bag WHERE ticketNo=1762341772625'''
print('Using timestamp_add function:')
fetch_data(handle,ts_func1)

ts_func2 = '''SELECT $s.ticketno, $bagInfo.bagArrivalDate, $flightLeg.flightDate,
              get_duration(timestamp_diff($bagInfo.bagArrivalDate, $flightLeg.flightDate)) AS diff
              FROM baggageinfo $s,
              $s.bagInfo[] AS $bagInfo, $bagInfo.flightLegs[] AS $flightLeg
              WHERE ticketNo=1762344493810'''
print('Using get_duration and timestamp_diff function:')
fetch_data(handle,ts_func2)

Per eseguire una query, utilizzare la funzione Client.Query.

Scarica il codice completo SQLFunctions.go dagli esempi qui.
 //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()))
   }
} 
ts_func1 := `SELECT timestamp_add(bag.bagInfo.flightLegs[0].estimatedArrival, "5 minutes")
                AS ARRIVAL_TIME FROM BaggageInfo bag WHERE ticketNo=1762341772625`
fmt.Printf("Using timestamp_add function::\n")
fetchData(client, err,tableName,ts_func1)

ts_func2 := `SELECT $s.ticketno, $bagInfo.bagArrivalDate, $flightLeg.flightDate,
             get_duration(timestamp_diff($bagInfo.bagArrivalDate, $flightLeg.flightDate)) AS diff
             FROM baggageinfo $s,
             $s.bagInfo[] AS $bagInfo, $bagInfo.flightLegs[] AS $flightLeg
             WHERE ticketNo=1762344493810`
fmt.Printf("Using get_duration and timestamp_diff function:\n")
fetchData(client, err,tableName,ts_func2)

Per eseguire una query, utilizzare il metodo query.

JavaScript: scarica il codice completo SQLFunctions.js dagli esempi qui.
  //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: scarica il codice completo SQLFunctions.ts dagli esempi qui.
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 ts_func1 = `SELECT timestamp_add(bag.bagInfo.flightLegs[0].estimatedArrival, "5 minutes")
                  AS ARRIVAL_TIME FROM BaggageInfo bag WHERE ticketNo=1762341772625`
console.log("Using timestamp_add function:");
await fetchData(handle,ts_func1);

const ts_func2 = `SELECT $s.ticketno, $bagInfo.bagArrivalDate, $flightLeg.flightDate,
                  get_duration(timestamp_diff($bagInfo.bagArrivalDate, $flightLeg.flightDate)) AS diff
                  FROM baggageinfo $s,
                  $s.bagInfo[] AS $bagInfo, $bagInfo.flightLegs[] AS $flightLeg
                  WHERE ticketNo=1762344493810`
console.log("Using get_duration and timestamp_diff function:");
await fetchData(handle,ts_func2);

Per eseguire una query, è possibile chiamare il metodo QueryAsync o chiamare il metodo GetQueryAsyncEnumerable e ripetere l'iterazione sull'enumerabile asincrono risultante.

Scarica il codice completo SQLFunctions.cs dagli esempi qui.
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 ts_func1 =@"SELECT timestamp_add(bag.bagInfo.flightLegs[0].estimatedArrival, ""5 minutes"")
                                       AS ARRIVAL_TIME FROM BaggageInfo bag WHERE ticketNo=1762341772625";
Console.WriteLine("\nUsing timestamp_add function!");
await fetchData(client,ts_func1);

private const string ts_func2 =@"SELECT $s.ticketno, $bagInfo.bagArrivalDate, $flightLeg.flightDate,
                                       get_duration(timestamp_diff($bagInfo.bagArrivalDate, $flightLeg.flightDate)) AS diff
                                       FROM baggageinfo $s,
                                       $s.bagInfo[] AS $bagInfo, $bagInfo.flightLegs[] AS $flightLeg
                                       WHERE ticketNo=1762344493810";
Console.WriteLine("\nUsing get_duration and timestamp_diff function!");
await fetchData(client,ts_func2);