Usando APIs para adicionar dados de tabela

Adicione linhas à sua tabela. Quando você armazena dados em linhas da tabela, seu aplicativo pode recuperar, adicionar ou excluir informações de uma tabela facilmente.

Você pode usar o método de classe PutRequest / put para executar colocações condicionais e incondicionais para:

• Substituir qualquer linha existente. Substituir é a funcionalidade padrão.
• Bem-sucedido somente se a linha não existir. Use o método IfAbsent nesse caso.
• Bem-sucedido somente se houver linha. Use o método IfPresent nesse caso.
• Êxito somente se a linha existe e a versão corresponde a uma versão específica. Use o método IfVersion para esse caso e o método setMatchVersion para especificar a versão com a qual a correspondência será feita.

• Java
• Python
• Go
• Node.js
• C#

A classe PutRequest fornece o método setValueFromJson que usa uma string JSON e a utiliza para preencher uma linha a ser inserida na tabela. A string JSON deve especificar nomes de campos que correspondam aos nomes dos campos da tabela.

Faça download do código completo AddData.java nos exemplos aqui.

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

A classe borneo.PutRequest representa a entrada no método borneo.NoSQLHandle.put() que é usado para inserir linhas únicas.

Você também pode adicionar dados JSON à sua tabela. No caso de uma tabela de esquema fixo, o JSON é convertido no esquema de destino. Os dados JSON podem ser inseridos diretamente em uma coluna do tipo JSON. O uso do tipo de dados JSON permite criar dados de tabela sem um esquema fixo, permitindo o uso mais flexível dos dados.

Faça download do código completo AddData.py nos exemplos aqui.

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

O nosqldb.PutRequest representa uma entrada para a função nosqldb.Put() e é usado para inserir linhas únicas.

O valor de dados fornecido para uma linha (em PutRequest) é um *types.MapValue. A parte key de cada entrada no MapValue deve corresponder ao nome da coluna da tabela de destino e a parte value deve ser um valor válido para a coluna. Os dados JSON também podem ser inseridos diretamente em uma coluna do tipo JSON. O uso do tipo de dados JSON permite criar dados de tabela sem um esquema fixo, permitindo o uso mais flexível dos dados.

Faça download do código completo AddData.go nos exemplos aqui.

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

Use o método put para inserir uma única linha na tabela. Para obter detalhes do método, consulte a classe NoSQLClient.

JavaScript: Faça download do código completo AddData.js nos exemplos aqui.

/* 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: Faça download do código completo AddData.ts nos exemplos aqui.

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

O método PutAsync e os métodos relacionados PutIfAbsentAsync, PutIfPresentAsync e PutIfVersionAsync são usados para inserir uma única linha na tabela ou atualizar uma única linha.

Cada um dos métodos Put acima retorna Task<PutResult<RecordValue>>. A instância PutResult contém informações sobre uma operação Put concluída, como status de sucesso (as operações de colocação condicional poderão falhar se a condição correspondente não for atendida) e o RowVersion resultante. Observe que a propriedade Sucesso do resultado indica apenas a conclusão bem-sucedida como relacionada às operações Put condicionais e é sempre verdadeira para Colocações incondicionais. Se a operação Put falhar por qualquer outro motivo, uma exceção será lançada. O uso de campos do tipo de dados JSON permite mais flexibilidade no uso de dados, pois os dados no campo JSON não têm um esquema predefinido. Para colocar valor em um campo JSON, forneça uma instância MapValue como seu valor de campo como parte do valor da linha. Você também pode criar seu valor com base em uma string JSON via FieldValue.FromJsonString.

Faça download do código completo AddData.cs nos exemplos aqui.

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

Você pode adicionar mais de uma linha de dados em uma única operação de banco de dados usando a API MultiWrite.

• Java
• Python
• Go
• Node.js
• C#

Você pode executar uma sequência de operações PutRequest associadas a uma tabela que compartilhem a mesma parte da chave de partição de suas chaves primárias como uma única operação de gravação atômica usando a classe WriteMultipleRequest. Você também pode adicionar dados simultaneamente a uma tabela pai e filha usando a classe WriteMultipleRequest. Essa é uma maneira eficiente de modificar atomicamente várias linhas relacionadas. Se a operação for bem-sucedida, o método WriteMultipleResult.getSuccess() retornará true.

Consulte Oracle NoSQL Java SDK API Reference para obter mais detalhes sobre as várias classes e métodos.

Faça download do código completo MultiWrite.java nos exemplos aqui.

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

Você pode executar uma sequência de operações PutRequest associadas a uma tabela que compartilham a mesma parte da chave de partição de suas chaves primárias como uma única operação de gravação atômica usando a classe borneo.WriteMultipleRequest. Você também pode adicionar dados simultaneamente a uma tabela pai e filha usando a classe borneo.WriteMultipleRequest. Essa é uma maneira eficiente de modificar atomicamente várias linhas relacionadas.

Consulte Oracle NoSQL Python SDK API Reference para obter mais detalhes sobre as várias classes e métodos.

Faça download do código completo MultiWrite.py nos exemplos aqui.

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)

Você pode executar uma sequência de operações PutRequest associadas a uma tabela que compartilhem a mesma parte da chave de partição de suas chaves primárias como uma única operação de gravação atômica usando a classe WriteMultipleRequest. Você também pode adicionar dados simultaneamente a uma tabela pai e filha usando a classe WriteMultipleRequest. Essa é uma maneira eficiente de modificar atomicamente várias linhas relacionadas.

Consulte Referência da API do Oracle NoSQL Go SDK para obter mais detalhes sobre as várias classes e métodos.

Faça download do código completo MultiWrite.go nos exemplos aqui.

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

Você pode executar uma sequência de operações put associadas a uma tabela que compartilham a mesma parte da chave de shard de suas chaves primárias como uma única operação de gravação atômica usando o método writeMany. Você também pode adicionar dados simultaneamente a uma tabela pai e filha usando o método writeMany. Essa é uma maneira eficiente de modificar atomicamente várias linhas relacionadas.

Para obter detalhes do método, consulte a classe NoSQLClient.

JavaScript: Faça download do código completo MultiWrite.js nos exemplos aqui.

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: Faça download do código completo MultiWrite.ts nos exemplos aqui.

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

Você pode executar uma sequência de operações put associadas a uma tabela que compartilham a mesma parte da chave de shard de suas chaves primárias como uma única operação de gravação atômica usando o método PutManyAsync. Você também pode adicionar dados simultaneamente a uma tabela pai e filha usando o método PutManyAsync. Essa é uma maneira eficiente de modificar atomicamente várias linhas relacionadas.

Consulte Oracle NoSQL Dotnet SDK API Reference para obter mais detalhes sobre todas as classes e métodos.

Faça download do código completo MultiWrite.cs nos exemplos aqui.

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

---

Título e Informações de Copyright

Usando APIs para adicionar dados de tabela

Copyright ©2023,2024,

Oracle e/ou suas empresas afiliadas.