Utilisation des API pour ajouter des données de table

Ajoutez des rangées à votre table. Lorsque vous stocker des données dans des rangées de table, votre application peut facilement extraire, ajouter ou supprimer des informations d'une table.

Vous pouvez utiliser la méthode PutRequest class / put pour effectuer des mises inconditionnelles et conditionnelles à :
  • Remplacer une rangée existante. Il s'agit de la fonctionnalité par défaut.
  • Ne réussir que si la rangée n'existe pas. Utilisez la méthode IfAbsent dans ce cas.
  • Ne réussir que si la rangée existe. Utilisez la méthode IfPresent dans ce cas.
  • N'aboutissez au succès que si la rangée existe et que la version correspond à une version spécifique. Utilisez la méthode IfVersion dans ce cas et la méthode setMatchVersion pour spécifier la version à mettre en correspondance.

La classe PutRequest fournit la méthode setValueFromJson qui utilise une chaîne JSON pour alimenter une rangée à insérer dans la table. La chaîne JSON doit spécifier les noms de champ correspondant aux noms de champ de la table.

Téléchargez le code complet AddData.java dans les exemples ici.
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 classe borneo.PutRequest représente l'entrée de la méthode borneo.NoSQLHandle.put() utilisée pour insérer des rangées uniques.

Vous pouvez également ajouter des données JSON à votre table. Dans le cas d'une table à schéma fixe, le JSON est converti en schéma cible. Les données JSON peuvent être insérées directement dans une colonne de type JSON. L'utilisation du type de données JSON vous permet de créer des données de table sans schéma fixe, ce qui permet une utilisation plus flexible des données.

Téléchargez le code complet AddData.py dans les exemples ici.
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 représente une entrée pour la fonction nosqldb.Put() et est utilisé pour insérer des rangées uniques.

La valeur de données fournie pour une rangée (dans PutRequest) est *types.MapValue. La partie key de chaque entrée dans MapValue doit correspondre au nom de colonne de la table cible et la partie value doit être une valeur valide pour la colonne. Les données JSON peuvent également être insérées directement dans une colonne de type JSON. L'utilisation du type de données JSON vous permet de créer des données de table sans schéma fixe, ce qui permet une utilisation plus flexible des données.

Téléchargez le code complet AddData.go dans les exemples ici.
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")
}

Vous utilisez la méthode put pour insérer une seule rangée dans la table. Pour plus de détails sur la méthode, voir la classe NoSQLClient.

JavaScript : Téléchargez le code complet AddData.js à partir des exemples ici.
/* 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 : Téléchargez le code complet AddData.ts à partir des exemples ici.
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");

La méthode PutAsync et les méthodes connexes PutIfAbsentAsync, PutIfPresentAsync et PutIfVersionAsync sont utilisées pour insérer une seule rangée dans la table ou mettre à jour une seule rangée.

Chacune des méthodes Put ci-dessus retourne Task<PutResult<RecordValue>>. L'instance PutResult contient des informations sur une opération Put terminée, telles que le statut de réussite (les opérations de mise conditionnelle peuvent échouer si la condition correspondante n'est pas satisfaite) et le résultat RowVersion. Notez que la propriété Success du résultat indique uniquement la réussite des opérations Put conditionnelles et est toujours vraie pour les Puts inconditionnels. Si l'opération Put échoue pour une autre raison, une exception sera générée. L'utilisation de champs de type de données JSON offre plus de flexibilité dans l'utilisation des données, car les données du champ JSON ne comportent pas de schéma prédéfini. Pour placer une valeur dans un champ JSON, fournissez une instance MapValue comme valeur de champ dans la valeur de la rangée. Vous pouvez également créer sa valeur à partir d'une chaîne JSON au moyen de FieldValue.FromJsonString.

Téléchargez le code complet AddData.cs dans les exemples ici.
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");      
   }
}

Rubriques connexes

Vous pouvez ajouter plus d'une rangée de données dans une seule opération de base de données à l'aide de l'API MultiWrite.

Vous pouvez effectuer une séquence d'opérations PutRequest associées à une table qui partage la même partie de clé de partition de leurs clés primaires qu'une seule opération d'écriture atomique à l'aide de la classe WriteMultipleRequest. Vous pouvez également ajouter des données simultanément à une table parent et à une table enfant à l'aide de la classe WriteMultipleRequest. Il s'agit d'un moyen efficace de modifier de manière atomique plusieurs lignes connexes. Si l'opération réussit, la méthode WriteMultipleResult.getSuccess() retourne la valeur Vrai.

Voir Informations de référence sur l'API de la trousse SDK Java pour Oracle NoSQL pour plus de détails sur les différentes classes et méthodes.

Téléchargez le code complet MultiWrite.java dans les exemples ici.
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);
}

Vous pouvez effectuer une séquence d'opérations PutRequest associées à une table qui partage la même partie de clé de partition de leurs clés primaires qu'une seule opération d'écriture atomique à l'aide de la classe borneo.WriteMultipleRequest. Vous pouvez également ajouter des données simultanément à une table parent et à une table enfant à l'aide de la classe borneo.WriteMultipleRequest. Il s'agit d'un moyen efficace de modifier de manière atomique plusieurs lignes connexes.

Voir Informations de référence sur l'API de la trousse SDK Python pour Oracle NoSQL pour plus de détails sur les différentes classes et méthodes.

Téléchargez le code complet MultiWrite.py dans les exemples ici.
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)

Vous pouvez effectuer une séquence d'opérations PutRequest associées à une table qui partage la même partie de clé de partition de leurs clés primaires qu'une seule opération d'écriture atomique à l'aide de la classe WriteMultipleRequest. Vous pouvez également ajouter des données simultanément à une table parent et à une table enfant à l'aide de la classe WriteMultipleRequest. Il s'agit d'un moyen efficace de modifier de manière atomique plusieurs lignes connexes.

Voir Informations de référence sur l'API de la trousse SDK Go pour Oracle NoSQL pour plus de détails sur les différentes classes et méthodes.

Téléchargez le code complet MultiWrite.go dans les exemples ici.
//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")
	}
}

Vous pouvez effectuer une séquence d'opérations Put associées à une table qui partage la même partie de clé de partition de leurs clés primaires qu'une seule opération d'écriture atomique à l'aide de la méthode writeMany. Vous pouvez également ajouter des données simultanément à une table parent et à une table enfant à l'aide de la méthode writeMany. Il s'agit d'un moyen efficace de modifier de manière atomique plusieurs lignes connexes.

Pour plus de détails sur la méthode, voir la classe NoSQLClient.

JavaScript : Téléchargez le code complet MultiWrite.js à partir des exemples ici.
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 : Téléchargez le code complet MultiWrite.ts à partir des exemples ici.
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);

Vous pouvez effectuer une séquence d'opérations Put associées à une table qui partage la même partie de clé de partition de leurs clés primaires qu'une seule opération d'écriture atomique à l'aide de la méthode PutManyAsync. Vous pouvez également ajouter des données simultanément à une table parent et à une table enfant à l'aide de la méthode PutManyAsync. Il s'agit d'un moyen efficace de modifier de manière atomique plusieurs lignes connexes.

Voir Informations de référence sur l'API de la trousse SDK Dotnet pour Oracle NoSQL pour plus de détails sur toutes les classes et méthodes.

Téléchargez le code complet MultiWrite.cs dans les exemples ici.
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)
         );
    }