Utiliser des API pour ajouter des données de table

Ajoutez des lignes à votre table. Lorsque vous stockez des données dans des lignes de table, l'application peut facilement extraire, ajouter ou supprimer des informations dans la table.

Vous pouvez utiliser la classe PutRequest / méthode put pour effectuer des opérations put inconditionnelles et conditionnelles sur :

• Ecraser toute ligne existante. L'écrasement est la fonctionnalité par défaut.

• Succès uniquement si la ligne n'existe pas. Utilisez la méthode IfAbsent dans ce cas.

• Succès uniquement si la ligne existe. Utilisez la méthode IfPresent dans ce cas.

• Succès uniquement si la ligne existe et que la version correspond à une version spécifique. Utilisez les méthodes IfVersion dans ce cas et setMatchVersion pour indiquer la version à mettre en correspondance.

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

La classe PutRequest fournit la méthode setValueFromJson qui utilise une chaîne JSON pour remplir une ligne à insérer dans la table. La chaîne JSON doit indiquer des noms de champ correspondant aux noms de champ de la table.

Téléchargez le code complet AddData.java à partir des 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 lignes uniques.

Vous pouvez également ajouter des données JSON à la table. Dans le cas d'une table de schéma fixe, le fichier JSON est converti en schéma cible. Les données JSON peuvent être directement insérées 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 à partir des 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 sert à insérer des lignes uniques.

La valeur de données fournie pour une ligne (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 directement insérées 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 à partir des 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")
}

La méthode put permet d'insérer une seule ligne dans la table. Pour plus de détails sur la méthode, reportez-vous à 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 associées PutIfAbsentAsync, PutIfPresentAsync et PutIfVersionAsync sont utilisées pour insérer une seule ligne dans la table ou pour mettre à jour une seule ligne.

Chacune des méthodes Put ci-dessus renvoie 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 put conditionnelles peuvent échouer si la condition correspondante n'a pas été remplie) et la version de ligne résultante. Notez que la propriété Succès du résultat indique uniquement la réussite des opérations Put conditionnelles et est toujours vraie pour les insertions inconditionnelles. Si l'opération Put échoue pour une autre raison, une exception est générée. L'utilisation de champs de type de données JSON permet une plus grande flexibilité dans l'utilisation des données car les données du champ JSON n'ont pas de schéma prédéfini. Pour ajouter une valeur à un champ JSON, indiquez une instance MapValue comme valeur de champ dans la valeur de ligne. Vous pouvez également créer sa valeur à partir d'une chaîne JSON via FieldValue.FromJsonString.

Téléchargez le code complet AddData.cs à partir des 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");
   }
}

Vous pouvez ajouter plusieurs lignes de données dans une seule opération de base de données à l'aide de l'API MultiWrite.

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

Vous pouvez effectuer une séquence d'opérations PutRequest associées à une table qui partagent la même partie de clé de shard que leurs clés primaires en tant qu'opération d'écriture atomique unique à 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 atomiquement plusieurs lignes associées. Si l'opération réussit, la méthode WriteMultipleResult.getSuccess() retourne la valeur True.

Pour plus de détails sur les différentes classes et méthodes, reportez-vous à Référence d'API du kit SDK Java Oracle NoSQL.

Téléchargez le code complet MultiWrite.java à partir des 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 partagent la même partie de clé de shard que leurs clés primaires en tant qu'opération d'écriture atomique unique à 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 atomiquement plusieurs lignes associées.

Pour plus de détails sur les différentes classes et méthodes, reportez-vous à Référence d'API du kit SDK Python Oracle NoSQL.

Téléchargez le code complet MultiWrite.py à partir des 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 partagent la même partie de clé de shard que leurs clés primaires en tant qu'opération d'écriture atomique unique à 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 atomiquement plusieurs lignes associées.

Pour plus de détails sur les différentes classes et méthodes, reportez-vous à Référence d'API du kit SDK Go Oracle NoSQL.

Téléchargez le code complet MultiWrite.go à partir des 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 partagent la même partie de clé de shard que leurs clés primaires en tant qu'opération d'écriture atomique unique à 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 atomiquement plusieurs lignes associées.

Pour plus de détails sur la méthode, reportez-vous à 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 partagent la même partie de clé de shard que leurs clés primaires en tant qu'opération d'écriture atomique unique à 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 atomiquement plusieurs lignes associées.

Pour plus de détails sur toutes les classes et méthodes, reportez-vous à Référence d'API du kit SDK Oracle NoSQL Dotnet.

Téléchargez le code complet MultiWrite.cs à partir des 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)
         );
    }

Rubriques connexes

• Connexion de l'application à NDCS
• Obtention d'un descripteur NoSQL
• A propos des compartiments
• Création de tables