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 :

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

Insertion de données dans une table de collecte JSON :

Vous pouvez insérer des champs de document de niveau supérieur dans une table de collecte JSON à l'aide d'une séquence d'opérations PutRequest. Pour les champs JSON imbriqués, vous pouvez fournir les données JSON sous forme de chaîne à l'opération putFromJson.

L'exemple de code suivant montre comment insérer des données dans la table stream_acct lorsqu'elle est créée en tant que table de collecte JSON.

String tableName = "stream_acct";

MapValue value = new MapValue()
        .put("acct_Id", 1)
        .put("profile_name", "AP")
        .put("account_expiry", "2023-10-18")
        .putFromJson(
                "acct_data",
                "{\"firstName\":\"Adam\","
              + "\"lastName\":\"Philip\","
              + "\"country\":\"Germany\"}",
                null);

PutRequest putRequest = new PutRequest()
        .setValue(value)
        .setTableName(tableName);

PutResult putRes = handle.put(putRequest);

System.out.println("Put row: " + value + " result=" + putRes);

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

Insertion de données dans une table de collecte JSON :

Vous pouvez ajouter une ligne directement dans la table de collecte JSON en tant que chaîne JSON.

L'exemple de code suivant montre comment insérer des données dans la table stream_acct lorsqu'elle est créée en tant que table de collecte JSON.

import json
from borneo import PutRequest

table_name = "stream_acct"

row = {
    "acct_Id": 1,
    "profile_name": "AP",
    "account_expiry": "2023-10-18",
    "acct_data": {
        "firstName": "Adam",
        "lastName": "Philip",
        "country": "Germany"
    }
}

request = (
    PutRequest()
    .set_table_name(table_name)
    .set_value_from_json(json.dumps(row))
)

result = handle.put(request)

print("Put row:", row, "result:", result)

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

Insertion de données dans une table de collecte JSON :

Vous pouvez créer une valeur de mapping à partir de données JSON et ajouter la ligne à la table de collecte JSON.

L'exemple de code suivant montre comment insérer des données dans la table stream_acct lorsqu'elle est créée en tant que table de collecte JSON.

tableName := "stream_acct"

rowJSON := `{
	"acct_Id": 1,
	"profile_name": "AP",
	"account_expiry": "2023-10-18",
	"acct_data": {
		"firstName": "Adam",
		"lastName": "Philip",
		"country": "Germany"
	}
}`

value, err := types.NewMapValueFromJSON(rowJSON)
if err != nil {
	return fmt.Errorf("invalid row JSON: %w", err)
}

request := &nosqldb.PutRequest{
	TableName: tableName,
	Value:     value,
}

result, err := client.Put(request)

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

Insertion de données dans une table de collecte JSON :

Vous pouvez ajouter une ligne dans la table de collecte JSON en fournissant un objet JavaScript simple avec des types JSON pris en charge.

L'exemple de code suivant montre comment insérer des données dans la table stream_acct lorsqu'elle est créée en tant que table de collecte JSON.

import { NoSQLClient } from 'oracle-nosqldb';

const client = new NoSQLClient('config.json');
const TABLE_NAME = 'stream_acct';

const record = {
    acct_Id: 1,
    profile_name: 'AP',
    account_expiry: '2023-10-18',
    acct_data: {
        firstName: 'Adam',
        lastName: 'Philip',
        country: 'Germany'
    }
};

async function writeARecord(client, record) {
    await client.put(TABLE_NAME, record);
    console.log('Added a row to the stream_acct table');
}

await writeARecord(client, record);

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

Insertion de données dans une table de collecte JSON :

Vous ajoutez une ligne dans la table de collecte JSON en mettant sa valeur à partir d'une chaîne JSON créée via la méthode FromJsonString.

L'exemple de code suivant montre comment insérer des données dans la table stream_acct lorsqu'elle est créée en tant que table de collecte JSON.

var tableName = "stream_acct";

const string data = @"{
    ""acct_Id"": 1,
    ""profile_name"": ""AP"",
    ""account_expiry"": ""2023-10-18"",
    ""acct_data"": {
        ""firstName"": ""Adam"",
        ""lastName"": ""Philip"",
        ""country"": ""Germany""
    }
}";

var result = await client.PutAsync(
    tableName,
    FieldValue.FromJsonString(data).AsMapValue
);

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.

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