Utilizzo delle API per aggiungere i dati delle tabelle

Aggiungere righe alla tabella. Quando si memorizzano i dati nelle righe di tabella, l'applicazione può recuperare, aggiungere o eliminare facilmente informazioni da una tabella.

È possibile utilizzare la classe PutRequest / il metodo put per eseguire operazioni di inserimento condizionale e non condizionale a:

• Sovrascrivere qualsiasi riga esistente. Sovrascrivi è la funzionalità predefinita.

• Procedere solo se la riga non esiste. In questo caso, utilizzare il metodo IfAbsent.

• Continuare solo se la riga esiste. In questo caso, utilizzare il metodo IfPresent.

• Procedere solo se la riga esiste e la versione corrisponde a una versione specifica. Utilizzare il metodo IfVersion per questo caso e il metodo setMatchVersion per specificare la versione da abbinare.

• Java
• Python
• Vai
• Node.js
• N. C

La classe PutRequest fornisce il metodo setValueFromJson che utilizza una stringa JSON per popolare una riga da inserire nella tabella. La stringa JSON deve specificare i nomi dei campi corrispondenti ai nomi dei campi della tabella.

Scarica il codice completo AddData.java dagli esempi qui.

private static void writeRows(NoSQLHandle handle, MapValue value)
                                               throws Exception {
   PutRequest putRequest =
     new PutRequest().setValue(value).setTableName(tableName);
   PutResult putResult = handle.put(putRequest);

   if (putResult.getVersion() != null) {
      System.out.println("Added a row to the stream_acct table");
   } else {
      System.out.println("Put failed");
   }
}

La classe borneo.PutRequest rappresenta l'input per il metodo borneo.NoSQLHandle.put() utilizzato per inserire singole righe.

È inoltre possibile aggiungere dati JSON alla tabella. Nel caso di una tabella a schema fisso, il file JSON viene convertito nello schema di destinazione. I dati JSON possono essere inseriti direttamente in una colonna di tipo JSON. L'uso del tipo di dati JSON consente di creare dati di tabella senza uno schema fisso, consentendo un uso più flessibile dei dati.

Scarica il codice completo AddData.py dagli esempi qui.

def insert_record(handle,table_name,acct_data):
  request = PutRequest().set_table_name(table_name)
                        .set_value_from_json(acct_data)

  handle.put(request)
  print('Added a row to the stream_acct table')

nosqldb.PutRequest rappresenta un input per la funzione nosqldb.Put() e viene utilizzato per inserire singole righe.

Il valore dei dati fornito per una riga (in PutRequest) è *types.MapValue. La parte key di ogni voce nel file MapValue deve corrispondere al nome colonna della tabella di destinazione e la parte value deve essere un valore valido per la colonna. I dati JSON possono anche essere inseriti direttamente in una colonna di tipo JSON. L'uso del tipo di dati JSON consente di creare dati di tabella senza uno schema fisso, consentendo un uso più flessibile dei dati.

Scarica il codice completo AddData.go dagli esempi qui.

func insertData(client *nosqldb.Client, err error,
                tableName string,value1 *types.MapValue )(){
  putReq := &nosqldb.PutRequest{
    	TableName: tableName,
    	Value: value1,
  }
  putRes, err := client.Put(putReq)
  if err != nil {
     fmt.Printf("failed to put single row: %v\n", err)
     return
  }
  fmt.Printf("Added a row to the stream_acct table\n")
}

Utilizzare il metodo put per inserire una singola riga nella tabella. Per i dettagli del metodo, vedere la classe NoSQLClient.

JavaScript: scarica il codice completo AddData.js dagli esempi qui.

/* Adding 3 records in acct_stream table */
let putResult = await handle.put(TABLE_NAME, JSON.parse(acct1));
let putResult1 = await handle.put(TABLE_NAME, JSON.parse(acct2));
let putResult2 = await handle.put(TABLE_NAME, JSON.parse(acct3));

console.log("Added rows to the stream_acct table");

TypeScript: scarica il codice completo AddData.ts dagli esempi qui.

interface StreamInt {
   acct_Id: Integer;
   profile_name: String;
   account_expiry: TIMESTAMP;
   acct_data: JSON;
}
/* Adding 3 records in acct_stream table */
let putResult = await handle.put<StreamInt>(TABLE_NAME, JSON.parse(acct1));
let putResult1 = await handle.put<StreamInt>(TABLE_NAME, JSON.parse(acct2));
let putResult2 = await handle.put<StreamInt>(TABLE_NAME, JSON.parse(acct3));

console.log("Added rows to the stream_acct table");

Il metodo PutAsync e i metodi correlati PutIfAbsentAsync, PutIfPresentAsync e PutIfVersionAsync vengono utilizzati per inserire una singola riga nella tabella o aggiornare una singola riga.

Ciascuno dei metodi Put sopra riportati restituisce Task<PutResult<RecordValue>>. L'istanza PutResult contiene informazioni su un'operazione Put completata, ad esempio lo stato di operazione riuscita (le operazioni put condizionali potrebbero non riuscire se la condizione corrispondente non è stata soddisfatta) e la RowVersion risultante. Si noti che la proprietà Success del risultato indica solo il completamento riuscito in relazione alle operazioni put condizionali ed è sempre vera per i Puts incondizionati. Se l'operazione put non riesce per qualsiasi altro motivo, verrà restituita un'eccezione. L'utilizzo di campi di tipo dati JSON consente una maggiore flessibilità nell'uso dei dati poiché i dati nel campo JSON non dispongono di uno schema predefinito. Per inserire un valore in un campo JSON, specificare un'istanza MapValue come valore del campo come parte del valore della riga. Puoi anche crearne il valore da una stringa JSON tramite FieldValue.FromJsonString.

Scarica il codice completo AddData.cs dagli esempi qui.

private static async Task insertData(NoSQLClient client, String acctdet){
   var putResult = await client.PutAsync(TableName,
                              FieldValue.FromJsonString(acctdet).AsMapValue);
   if (putResult.ConsumedCapacity != null)
   {
      Console.WriteLine(" Added a row to the stream_acct table");
   }
}

È possibile aggiungere più di una riga di dati in una singola operazione di database utilizzando l'API MultiWrite.

• Java
• Python
• Vai
• Node.js
• N. C

È possibile eseguire una sequenza di operazioni PutRequest associate a una tabella che condivide la stessa parte della chiave partizione delle chiavi primarie di una singola operazione di scrittura atomica utilizzando la classe WriteMultipleRequest. È inoltre possibile aggiungere contemporaneamente dati a una tabella padre e figlio utilizzando la classe WriteMultipleRequest. Questo è un modo efficiente per modificare atomicamente più righe correlate. Se l'operazione riesce, il metodo WriteMultipleResult.getSuccess() restituisce true.

Per ulteriori dettagli sulle varie classi e metodi, vedere Oracle NoSQL Java SDK API Reference.

Scarica il codice completo MultiWrite.java dagli esempi qui.

private static void writeMul(NoSQLHandle handle,String parent_tblname,
String parent_data, String child_tblname, String child_data){
      WriteMultipleRequest umRequest = new WriteMultipleRequest();
      PutRequest putRequest =
         new PutRequest().setValueFromJson(parent_data,null).setTableName(parent_tblname);
      umRequest.add(putRequest, false);
      putRequest =
         new PutRequest().setValueFromJson(child_data,null).setTableName(child_tblname);
      umRequest.add(putRequest, false);
      WriteMultipleResult umResult = handle.writeMultiple(umRequest);
}

È possibile eseguire una sequenza di operazioni PutRequest associate a una tabella che condivide la stessa parte della chiave partizione delle chiavi primarie di una singola operazione di scrittura atomica utilizzando la classe borneo.WriteMultipleRequest. È inoltre possibile aggiungere contemporaneamente dati a una tabella padre e figlio utilizzando la classe borneo.WriteMultipleRequest. Questo è un modo efficiente per modificare atomicamente più righe correlate.

Per ulteriori dettagli sulle varie classi e metodi, vedere Oracle NoSQL Python SDK API Reference.

Scarica il codice completo MultiWrite.py dagli esempi qui.

def mul_write(handle,parent_tblname,parent_data,
child_tblname, child_data):
    request = PutRequest()
    request.set_value_from_json(parent_data)
    request.set_table_name('ticket')
    wm_req.add(request, True)
    request1 = PutRequest()
    request1.set_table_name(child_tblname)
    request1.set_value_from_json(child_data)
    wm_req.add(request1, True)
    result = handle.write_multiple(wm_req)

È possibile eseguire una sequenza di operazioni PutRequest associate a una tabella che condivide la stessa parte della chiave partizione delle chiavi primarie di una singola operazione di scrittura atomica utilizzando la classe WriteMultipleRequest. È inoltre possibile aggiungere contemporaneamente dati a una tabella padre e figlio utilizzando la classe WriteMultipleRequest. Questo è un modo efficiente per modificare atomicamente più righe correlate.

Per ulteriori dettagli sulle varie classi e metodi, vedere Oracle NoSQL Go SDK API Reference.

Scarica il codice completo MultiWrite.go dagli esempi qui.

//multiple write from the table
func mul_write(client *nosqldb.Client, err error, parenttbl_name string,
parent_data string, childtbl_name string, child_data string)(){
   value, err := types.NewMapValueFromJSON(parent_data)
	putReq := &nosqldb.PutRequest{
      TableName: parenttbl_name,
      Value:     value,
   }
	wmReq := &nosqldb.WriteMultipleRequest{
		TableName: "",
		Timeout:   10 * time.Second,
	}
   wmReq.AddPutRequest(putReq, true)

	value1, err := types.NewMapValueFromJSON(child_data)
	putReq1 := &nosqldb.PutRequest{
      TableName: childtbl_name,
      Value:     value1,
   }
   wmReq.AddPutRequest(putReq1, true)
	wmRes, err := client.WriteMultiple(wmReq)
	if err != nil {
		fmt.Printf("WriteMultiple() failed: %v\n", err)
		return
	}
	if wmRes.IsSuccess() {
		fmt.Printf("WriteMultiple() succeeded\n")
	} else {
		fmt.Printf("WriteMultiple() failed\n")
	}
}

È possibile eseguire una sequenza di operazioni put associate a una tabella che condividono la stessa parte della chiave partizione delle chiavi primarie di una singola operazione di scrittura atomica utilizzando il metodo writeMany. È inoltre possibile aggiungere contemporaneamente dati a una tabella padre e figlio utilizzando il metodo writeMany. Questo è un modo efficiente per modificare atomicamente più righe correlate.

Per i dettagli del metodo, vedere la classe NoSQLClient.

JavaScript: scarica il codice completo MultiWrite.js dagli esempi qui.

const ops = [
               {
                  tableName: 'ticket',
                  put: {
                     "ticketNo": "1762344493810",
                     "confNo" : "LE6J4Z"
                  },
                  abortOnFail: true
               },
               {
                  tableName: 'ticket.bagInfo',
                  put: {
                     "ticketNo":"1762344493810",
                     "id":"79039899165297",
                     "tagNum":"17657806255240",
                     "routing":"MIA/LAX/MEL",
                     "lastActionCode":"OFFLOAD",
                     "lastActionDesc":"OFFLOAD",
                     "lastSeenStation":"MEL",
                     "lastSeenTimeGmt":"2019-02-01T16:13:00Z",
                     "bagArrivalDate":"2019-02-01T16:13:00Z"
                   },
                  abortOnFail: true
               }
            ];

const res = await handle.writeMany(ops, null);

TypeScript: scarica il codice completo MultiWrite.ts dagli esempi qui.

const ops = [
               {
                  tableName: 'ticket',
                  put: {
                     "ticketNo": "1762344493810",
                     "confNo" : "LE6J4Z"
                  },
                  abortOnFail: true
               },
               {
                  tableName: 'ticket.bagInfo',
                  put: {
                     "ticketNo":"1762344493810",
                     "id":"79039899165297",
                     "tagNum":"17657806255240",
                     "routing":"MIA/LAX/MEL",
                     "lastActionCode":"OFFLOAD",
                     "lastActionDesc":"OFFLOAD",
                     "lastSeenStation":"MEL",
                     "lastSeenTimeGmt":"2019-02-01T16:13:00Z",
                     "bagArrivalDate":"2019-02-01T16:13:00Z"
                   },
                  abortOnFail: true
               }
            ];

const res = await handle.writeMany(ops, null);

È possibile eseguire una sequenza di operazioni put associate a una tabella che condividono la stessa parte della chiave partizione delle chiavi primarie di una singola operazione di scrittura atomica utilizzando il metodo PutManyAsync. È inoltre possibile aggiungere contemporaneamente dati a una tabella padre e figlio utilizzando il metodo PutManyAsync. Questo è un modo efficiente per modificare atomicamente più righe correlate.

Per ulteriori dettagli su tutte le classi e i metodi, consulta la riferimento API Oracle NoSQL Dotnet SDK.

Scarica il codice completo MultiWrite.cs dagli esempi qui.

private static async Task mul_write(NoSQLClient client,string parentbl_name,
string data1, string childtbl_name, string data2){
    var result = await client.WriteManyAsync(
        new WriteOperationCollection()
          .AddPut(parentbl_name, FieldValue.FromJsonString(data1).AsMapValue)
          .AddPut(childtbl_name, FieldValue.FromJsonString(data2).AsMapValue)
         );
    }

Argomenti correlati

• Connessione dell'applicazione a NDCS
• Come ottenere un handle NoSQL
• Informazioni sui compartimenti
• Creazione delle tabelle