Usando APIs para adicionar dados de tabela

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

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

Substituir qualquer linha existente. Substituir é a funcionalidade padrão.
Só terá sucesso 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.
Bem-sucedido somente se a linha existir e a versão corresponder a uma versão específica. Utilize o método IfVersion para esse caso e o método setMatchVersion para especificar a versão a ser correspondente.

A classe PutRequest fornece o método setValueFromJson que utiliza uma string JSON e usa isso 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 para o 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 dos 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 dos 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");

Os métodos PutAsync e 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 condicionais poderão falhar se a condição correspondente não for atendida) e a 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 Puts incondicionais. Se a operação Put falhar por qualquer outro motivo, uma exceção será gerada. 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.

Você pode executar uma sequência de operações PutRequest associadas a uma tabela que compartilha a mesma parte da chave de shard 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 forma eficiente de modificar atomicamente várias linhas relacionadas. Se a operação for bem-sucedida, o método WriteMultipleResult.getSuccess() retornará verdadeiro.

Consulte Referência da API do Oracle NoSQL Java SDK 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 compartilha a mesma parte da chave de shard 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 forma eficiente de modificar atomicamente várias linhas relacionadas.

Consulte Referência da API do Oracle NoSQL Python SDK 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)

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 de 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 forma 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 dos 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 de 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 forma eficiente de modificar atomicamente várias linhas relacionadas.

Consulte Referência da API do SDK do Oracle NoSQL Dotnet 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)
         );
    }

Usando APIs para adicionar dados de tabela

Tópicos Relacionados