Uso de API para agregar datos de tabla

Agregue filas a la tabla. Al almacenar datos en filas de tablas, la aplicación puede recuperar, agregar o suprimir información de una tabla fácilmente.

Puede utilizar el método de clase PutRequest / put para realizar operaciones put incondicionales y condicionales a:
  • Sustituir una fila existente. Overwrite es la funcionalidad por defecto.
  • Se realiza correctamente solo si la fila no existe. Utilice el método IfAbsent en este caso.
  • Se realiza correctamente solo si la fila existe. Utilice el método IfPresent en este caso.
  • Se realiza correctamente solo si la fila existe y la versión coincide con una versión específica. Utilice el método IfVersion en este caso y el método setMatchVersion para especificar la versión que debe coincidir.

La clase PutRequest proporciona el método setValueFromJson, que toma una cadena JSON y la utiliza para rellenar una fila para insertarla en la tabla. La cadena JSON debe especificar los nombres de campo que corresponden a los nombres de campo de la tabla.

Descargue el código completo AddData.java de los ejemplos aquí.
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 clase borneo.PutRequest representa la entrada al método borneo.NoSQLHandle.put() que se utiliza para insertar filas únicas.

También puede agregar datos JSON a la tabla. En el caso de una tabla de esquema fijo, el JSON se convierte en el esquema de destino. Los datos JSON se pueden insertar directamente en una columna de tipo JSON. El uso del tipo de dato JSON permite crear datos de tabla sin un esquema fijo, lo que permite un uso más flexible de los datos.

Descargue el código completo AddData.py de los ejemplos aquí.
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 representa una entrada para la función nosqldb.Put() y se utiliza para insertar filas únicas.

El valor de datos proporcionado para una fila (en PutRequest) es *types.MapValue. La parte key de cada entrada de MapValue debe coincidir con el nombre de columna de la tabla de destino y la parte value debe ser un valor válido para la columna. Los datos JSON también se pueden insertar directamente en una columna de tipo JSON. El uso del tipo de dato JSON permite crear datos de tabla sin un esquema fijo, lo que permite un uso más flexible de los datos.

Descargue el código completo AddData.go de los ejemplos aquí.
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")
}

Utilice el método put para insertar una sola fila en la tabla. Para obtener detalles sobre el método, consulte la clase NoSQLClient.

JavaScript: descargue el código completo AddData.js de los ejemplos aquí.
/* 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: descargue el código completo AddData.ts de los ejemplos aquí.
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");

El método PutAsync y los métodos relacionados PutIfAbsentAsync, PutIfPresentAsync y PutIfVersionAsync se utilizan para insertar una sola fila en la tabla o actualizar una sola fila.

Cada uno de los métodos Put anteriores devuelve Task<PutResult<RecordValue>>. La instancia PutResult contiene información sobre una operación Put finalizada, como el estado correcto (las operaciones put condicionales pueden fallar si no se cumple la condición correspondiente) y el RowVersion resultante. Tenga en cuenta que la propiedad Correcto del resultado solo indica que la finalización correcta está relacionada con operaciones PUT condicionales y siempre es verdadera para PUT incondicionales. Si la operación de colocación falla por cualquier otro motivo, se devolverá una excepción. El uso de campos de tipo de dato JSON permite una mayor flexibilidad en el uso de datos, ya que los datos del campo JSON no tienen un esquema predefinido. Para poner valor en un campo JSON, proporcione una instancia MapValue como valor de campo como parte del valor de fila. También puede crear su valor a partir de una cadena JSON mediante FieldValue.FromJsonString.

Descargue el código completo AddData.cs de los ejemplos aquí.
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");      
   }
}

Temas relacionados

Puede agregar más de una fila de datos en una sola operación de base de datos mediante la API MultiWrite.

Puede realizar una secuencia de operaciones PutRequest asociadas a una tabla que comparte la misma parte de la clave de partición horizontal de sus claves primarias que una única operación de escritura atómica con la clase WriteMultipleRequest. También puede agregar datos simultáneamente a una tabla principal y secundaria mediante la clase WriteMultipleRequest. Esta es una forma eficaz de modificar atómicamente varias filas relacionadas. Si la operación se realiza correctamente, el método WriteMultipleResult.getSuccess() devuelve true.

Consulte Referencia de API de SDK de Java de Oracle NoSQL para obtener más información sobre las distintas clases y métodos.

Descargue el código completo MultiWrite.java de los ejemplos aquí.
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);
}

Puede realizar una secuencia de operaciones PutRequest asociadas a una tabla que comparte la misma parte de clave de partición horizontal de sus claves primarias como una única operación de escritura atómica mediante la clase borneo.WriteMultipleRequest. También puede agregar datos simultáneamente a una tabla principal y secundaria mediante la clase borneo.WriteMultipleRequest. Esta es una forma eficaz de modificar atómicamente varias filas relacionadas.

Consulte Referencia de API de SDK de Python de Oracle NoSQL para obtener más información sobre las distintas clases y métodos.

Descargue el código completo MultiWrite.py de los ejemplos aquí.
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)

Puede realizar una secuencia de operaciones PutRequest asociadas a una tabla que comparte la misma parte de la clave de partición horizontal de sus claves primarias que una única operación de escritura atómica con la clase WriteMultipleRequest. También puede agregar datos simultáneamente a una tabla principal y secundaria mediante la clase WriteMultipleRequest. Esta es una forma eficaz de modificar atómicamente varias filas relacionadas.

Consulte Referencia de API de SDK de Go de Oracle NoSQL para obtener más información sobre las distintas clases y métodos.

Descargue el código completo MultiWrite.go de los ejemplos aquí.
//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")
	}
}

Puede realizar una secuencia de operaciones put asociadas a una tabla que compartan la misma parte de clave de partición horizontal de sus claves primarias que una única operación de escritura atómica mediante el método writeMany. También puede agregar datos simultáneamente a una tabla principal y secundaria mediante el método writeMany. Esta es una forma eficaz de modificar atómicamente varias filas relacionadas.

Para obtener detalles sobre el método, consulte la clase NoSQLClient.

JavaScript: descargue el código completo MultiWrite.js de los ejemplos aquí.
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: descargue el código completo MultiWrite.ts de los ejemplos aquí.
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);

Puede realizar una secuencia de operaciones put asociadas a una tabla que compartan la misma parte de clave de partición horizontal de sus claves primarias que una única operación de escritura atómica mediante el método PutManyAsync. También puede agregar datos simultáneamente a una tabla principal y secundaria mediante el método PutManyAsync. Esta es una forma eficaz de modificar atómicamente varias filas relacionadas.

Consulte Referencia de API de SDK de Dotnet de Oracle NoSQL para obtener más información sobre todas las clases y métodos.

Descargue el código completo MultiWrite.cs de los ejemplos aquí.
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)
         );
    }