Mit APIs Tabellendaten 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.

Sie können die Methode PutRequest class / put verwenden, um bedingungslose und bedingte Put-Befehle auszuführen:
  • Löschen Sie alle 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 in diesem Fall die Methode IfVersion, und geben Sie mit der Methode setMatchVersion die Version für den Abgleich an.

Die Klasse PutRequest stellt die Methode setValueFromJson bereit, die eine JSON-Zeichenfolge zum Einfügen einer Zeile in die Tabelle verwendet. 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, mit der einzelne Zeilen eingefügt werden.

Sie können der Tabelle auch JSON-Daten hinzufügen. Bei einer Tabelle mit festem Schema wird die JSON in das Zielschema konvertiert. JSON-Daten können direkt in eine Spalte des Typs JSON eingefügt werden. Mit dem JSON-Datentyp können Sie Tabellendaten ohne festes Schema erstellen, sodass die Daten flexibler verwendet werden können.

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

nosqldb.PutRequest stellt eine Eingabe für die Funktion nosqldb.Put() 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 MapValue muss mit dem Spaltennamen der Zieltabelle übereinstimmen, und der value -Teil muss ein gültiger Wert für die Spalte sein. JSON-Daten können auch direkt in eine Spalte des Typs JSON eingefügt werden. Mit dem JSON-Datentyp können Sie Tabellendaten ohne festes Schema erstellen, sodass die Daten flexibler verwendet werden können.

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

Mit der Methode put fügen Sie eine einzelne Zeile in die Tabelle ein. Details zur Methode 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");

Mit der Methode PutAsync und den zugehörigen Methoden PutIfAbsentAsync, PutIfPresentAsync und PutIfVersionAsync wird eine einzelne Zeile in die Tabelle eingefügt oder eine einzelne Zeile aktualisiert.

Jede der obigen Put-Methoden gibt Task<PutResult<RecordValue>> zurück. Die PutResult-Instanz enthält Informationen zu einem abgeschlossenen Put-Vorgang, wie Erfolgsstatus (bedingte Put-Vorgänge sind möglicherweise nicht erfolgreich, wenn die entsprechende Bedingung nicht erfüllt wurde) und resultierender RowVersion. Beachten Sie, dass die Erfolgseigenschaft des Ergebnisses nur auf einen erfolgreichen Abschluss im Zusammenhang mit bedingten Put-Vorgängen hinweist und bei nicht bedingten Put-Vorgängen immer zutrifft. 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 über FieldValue.FromJsonString aus einer JSON-Zeichenfolge 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");      
   }
}

Verwandte Themen

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

Sie können eine Folge 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 verwenden. Sie können auch gleichzeitig Daten zu einer übergeordneten und untergeordneten Tabelle mit der Klasse WriteMultipleRequest 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 unter 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 verwenden. Sie können auch gleichzeitig Daten zu einer übergeordneten und untergeordneten Tabelle mit der Klasse borneo.WriteMultipleRequest 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 unter 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)

Sie können eine Folge 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 verwenden. Sie können auch gleichzeitig Daten zu einer übergeordneten und untergeordneten Tabelle mit der Klasse WriteMultipleRequest 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 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 Folge 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 verwenden. Sie können auch gleichzeitig Daten zu einer übergeordneten und untergeordneten Tabelle mit der Methode writeMany hinzufügen. Dies ist eine effiziente Möglichkeit, mehrere zugehörige Zeilen atomar zu ändern.

Details zur Methode 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 Folge 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 verwenden. Sie können auch gleichzeitig Daten zu einer übergeordneten und untergeordneten Tabelle mit der Methode PutManyAsync hinzufügen. Dies ist eine effiziente Möglichkeit, mehrere zugehörige Zeilen atomar zu ändern.

Weitere Details zu allen Klassen und Methoden finden Sie in der Oracle NoSQL Dotnet-SDK-API-Referenz.

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