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 le informazioni da una tabella.

È possibile utilizzare il metodo PutRequest class / put per eseguire put incondizionati e condizionali per:
  • Consente di sovrascrivere qualsiasi riga esistente. Sovrascrivi è la funzionalità predefinita.
  • Riuscito solo se la riga non esiste. In questo caso, utilizzare il metodo IfAbsent.
  • Riuscito solo se la riga esiste. In questo caso, utilizzare il metodo IfPresent.
  • Riuscito 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.

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 righe singole.

Puoi anche aggiungere dati JSON alla tua tabella. Nel caso di una tabella con schema fisso, la notazione JSON viene convertita 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 i dati della 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 righe singole.

Il valore 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 i dati della 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")
}

Il metodo put consente di inserire una sola riga nella tabella. Per ulteriori informazioni sul 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 riportati sopra 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 il risultato RowVersion. Tenere presente che la proprietà Successo del risultato indica solo il completamento riuscito in relazione alle operazioni put condizionali ed è sempre vero per gli inserimenti incondizionati. Se l'operazione Put non riesce per qualsiasi altro motivo, verrà restituita un'eccezione. L'uso 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, fornire un'istanza MapValue come valore di campo come parte del valore di riga. È inoltre possibile 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");      
   }
}

Argomenti correlati

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

È possibile eseguire una sequenza di operazioni PutRequest associate a una tabella che condividono la stessa parte della chiave di partizione delle relative chiavi primarie come 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 informazioni sulle varie classi e metodi, consulta 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 condividono la stessa parte della chiave di partizione delle relative chiavi primarie come 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 informazioni 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 condividono la stessa parte della chiave di partizione delle relative chiavi primarie come 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.

Consulta Oracle NoSQL Go SDK API Reference per ulteriori dettagli sulle varie classi e metodi.

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 di partizione delle relative chiavi primarie come 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 ulteriori informazioni sul 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 di partizione delle relative chiavi primarie come 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 informazioni su tutte le classi e i metodi, consulta Oracle NoSQL Dotnet SDK API Reference.

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)
         );
    }