Tabellendaten mit APIs hinzufügen

Fügen Sie der Tabelle Zeilen hinzu. Wenn Sie Daten in Tabellenzeilen speichern, kann Ihre Anwendung einfach Informationen aus einer Tabelle abrufen sowie Informationen hinzufügen oder löschen.

Mit der Methode PutRequest class / put können Sie unbedingte und bedingte Puts für Folgendes ausführen:

Überschreiben von vorhandenen Zeilen. Überschreiben ist die Standardfunktionalität.
Nur erfolgreich, wenn die Zeile nicht vorhanden ist. Verwenden Sie in diesem Fall die Methode IfAbsent.
Nur erfolgreich, wenn die Zeile vorhanden ist. Verwenden Sie in diesem Fall die Methode IfPresent.
Nur erfolgreich, wenn die Zeile vorhanden ist und die Version mit einer bestimmten Version übereinstimmt. Verwenden Sie die Methode IfVersion für diesen Fall und die Methode setMatchVersion, um die Version für den Abgleich anzugeben.

Die Klasse PutRequest stellt die Methode setValueFromJson bereit, die eine JSON-Zeichenfolge zum Auffüllen einer Zeile verwendet, die in die Tabelle eingefügt werden soll. Die JSON-Zeichenfolge muss Feldnamen angeben, die den Tabellenfeldnamen entsprechen.

Laden Sie den vollständigen Code AddData.java aus den Beispielen hier herunter.

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

Die Klasse borneo.PutRequest stellt die Eingabe für die Methode borneo.NoSQLHandle.put() dar, die zum Einfügen einzelner Zeilen verwendet wird.

Sie können der Tabelle auch JSON-Daten hinzufügen. Bei einer festen Schematabelle wird die JSON in das Zielschema konvertiert. JSON-Daten können direkt in eine Spalte des Typs "JSON" eingefügt werden. Durch die Verwendung des JSON-Datentyps können Sie Tabellendaten ohne festes Schema erstellen und so die Daten flexibler verwenden.

Laden Sie den vollständigen Code AddData.py aus den Beispielen hier herunter.

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')

Die nosqldb.PutRequest stellt eine Eingabe in die nosqldb.Put() -Funktion dar und wird zum Einfügen einzelner Zeilen verwendet.

Der für eine Zeile (in PutRequest) angegebene Datenwert ist *types.MapValue. Der key-Teil jedes Eintrags in der MapValue muss mit dem Spaltennamen der Zieltabelle übereinstimmen. Der value -Teil muss ein gültiger Wert für die Spalte sein. JSON-Daten können auch direkt in eine Spalte vom Typ JSON eingefügt werden. Durch die Verwendung des JSON-Datentyps können Sie Tabellendaten ohne festes Schema erstellen und so die Daten flexibler verwenden.

Laden Sie den vollständigen Code AddData.go aus den Beispielen hier herunter.

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

Sie verwenden die Methode put, um eine einzelne Zeile in die Tabelle einzufügen. Methodendetails finden Sie in der Klasse NoSQLClient.

JavaScript: Laden Sie den vollständigen Code AddData.js aus den Beispielen hier herunter.

/* 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: Laden Sie den vollständigen Code AddData.ts aus den Beispielen hier herunter.

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

Die Methode PutAsync und die zugehörigen Methoden PutIfAbsentAsync, PutIfPresentAsync und PutIfVersionAsync werden verwendet, um eine einzelne Zeile in die Tabelle einzufügen oder eine einzelne Zeile zu aktualisieren.

Jede der obigen Put-Methoden gibt Task<PutResult<RecordValue>> zurück. Die PutResult-Instanz enthält Informationen zu einem abgeschlossenen Put-Vorgang, wie z.B. den Status "Erfolg" (bedingte Put-Vorgänge sind möglicherweise nicht erfolgreich, wenn die entsprechende Bedingung nicht erfüllt wurde) und die resultierende RowVersion. Beachten Sie, dass die Erfolgseigenschaft des Ergebnisses nur einen erfolgreichen Abschluss in Bezug auf bedingte Put-Vorgänge anzeigt und immer für bedingungslose Puts gilt. Wenn der Put-Vorgang aus einem anderen Grund nicht erfolgreich verläuft, wird eine Ausnahme ausgelöst. Die Verwendung von Feldern des Datentyps JSON ermöglicht mehr Flexibilität bei der Verwendung von Daten, da die Daten im JSON-Feld kein vordefiniertes Schema aufweisen. Um einen Wert in ein JSON-Feld einzufügen, geben Sie eine MapValue-Instanz als Feldwert als Teil des Zeilenwerts an. Sie können den Wert auch aus einer JSON-Zeichenfolge über FieldValue.FromJsonString erstellen.

Laden Sie den vollständigen Code AddData.cs aus den Beispielen hier herunter.

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

Mit der MultiWrite-API können Sie mehr als eine Datenzeile in einem einzelnen Datenbankvorgang hinzufügen.

Sie können eine Sequenz von PutRequest-Vorgängen ausführen, die mit einer Tabelle verknüpft sind, die denselben Shard-Schlüsselteil ihrer Primärschlüssel wie ein einzelner atomarer Schreibvorgang mit der Klasse WriteMultipleRequest gemeinsam verwenden. Mit der Klasse WriteMultipleRequest können Sie gleichzeitig Daten zu einer übergeordneten und untergeordneten Tabelle hinzufügen. Dies ist eine effiziente Möglichkeit, mehrere zugehörige Zeilen atomar zu ändern. Wenn der Vorgang erfolgreich ist, gibt die Methode WriteMultipleResult.getSuccess() "true" zurück.

Weitere Informationen zu den verschiedenen Klassen und Methoden finden Sie in der Oracle NoSQL Java SDK-API-Referenz.

Laden Sie den vollständigen Code MultiWrite.java aus den Beispielen hier herunter.

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

Sie können eine Sequenz von PutRequest-Vorgängen ausführen, die mit einer Tabelle verknüpft sind, die denselben Shard-Schlüsselteil ihrer Primärschlüssel wie ein einzelner atomarer Schreibvorgang mit der Klasse borneo.WriteMultipleRequest gemeinsam verwenden. Mit der Klasse borneo.WriteMultipleRequest können Sie gleichzeitig Daten zu einer übergeordneten und untergeordneten Tabelle hinzufügen. Dies ist eine effiziente Möglichkeit, mehrere zugehörige Zeilen atomar zu ändern.

Weitere Informationen zu den verschiedenen Klassen und Methoden finden Sie in der Oracle NoSQL Python-SDK-API-Referenz.

Laden Sie den vollständigen Code MultiWrite.py aus den Beispielen hier herunter.

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)

Weitere Informationen zu den verschiedenen Klassen und Methoden finden Sie in der Oracle NoSQL Go-SDK-API-Referenz.

Laden Sie den vollständigen Code MultiWrite.go aus den Beispielen hier herunter.

//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")
	}
}

Sie können eine Sequenz von put-Vorgängen ausführen, die mit einer Tabelle verknüpft sind, die denselben Shard-Schlüsselteil ihrer Primärschlüssel wie ein einzelner atomarer Schreibvorgang mit der Methode writeMany gemeinsam verwenden. Sie können Daten auch gleichzeitig mit der Methode writeMany zu einer übergeordneten und untergeordneten Tabelle hinzufügen. Dies ist eine effiziente Möglichkeit, mehrere zugehörige Zeilen atomar zu ändern.

Methodendetails finden Sie in der Klasse NoSQLClient.

JavaScript: Laden Sie den vollständigen Code MultiWrite.js aus den Beispielen hier herunter.

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: Laden Sie den vollständigen Code MultiWrite.ts aus den Beispielen hier herunter.

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

Sie können eine Sequenz von put-Vorgängen ausführen, die mit einer Tabelle verknüpft sind, die denselben Shard-Schlüsselteil ihrer Primärschlüssel wie ein einzelner atomarer Schreibvorgang mit der Methode PutManyAsync gemeinsam verwenden. Sie können Daten auch gleichzeitig mit der Methode PutManyAsync zu einer übergeordneten und untergeordneten Tabelle hinzufügen. Dies ist eine effiziente Möglichkeit, mehrere zugehörige Zeilen atomar zu ändern.

Weitere Informationen zu allen Klassen und Methoden finden Sie in der Oracle NoSQL Dotnet SDK API Reference.

Laden Sie den vollständigen Code MultiWrite.cs aus den Beispielen hier herunter.

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

Tabellendaten mit APIs hinzufügen

Verwandte Themen