Utiliser des API pour ajouter des données à des tables
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.
PutRequest / put pour effectuer des opérations d'insertion inconditionnelles et conditionnelles pour :
- Ecraser toute ligne existante. Le remplacement est la fonctionnalité par défaut.
- Succès uniquement si la ligne n'existe pas. Utilisez dans ce cas la méthode
IfAbsent. - Succès uniquement si la ligne existe. Utilisez dans ce cas la méthode
IfPresent. - Succès uniquement si la ligne existe et que la version correspond à une version spécifique. Utilisez la méthode
IfVersiondans ce cas et la méthodesetMatchVersionpour indiquer la version à mettre en correspondance.
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 correspondants.
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 à schéma fixe, le 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.
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 de la fonction nosqldb.Put() et est utilisé pour 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.
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")
} Utilisez la méthode put pour insérer une seule ligne dans la table. Pour plus d'informations sur les méthodes, reportez-vous à la classe NoSQLClient.
/* 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");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 permettent d'insérer une seule ligne dans la table ou de 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'est pas remplie) et la valeur RowVersion obtenue. 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 est 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 n'ont pas de schéma prédéfini. Pour insérer une valeur dans 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.
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.
Vous pouvez effectuer une séquence d'opérations PutRequest associée à une table qui partage la même partie de clé de partage de leurs clés primaires qu'une seule opération d'écriture atomique à l'aide de la classe WriteMultipleRequest. Vous pouvez également ajouter simultanément des données à une table parent et 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() renvoie la valeur True.
Pour plus d'informations sur les différentes classes et méthodes, reportez-vous à Référence d'API du kit SDK Java Oracle NoSQL.
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 de leurs clés primaires qu'une seule opération d'écriture atomique à l'aide de la classe borneo.WriteMultipleRequest. Vous pouvez également ajouter simultanément des données à une table parent et enfant à l'aide de la classe borneo.WriteMultipleRequest. Il s'agit d'un moyen efficace de modifier atomiquement plusieurs lignes associées.
Pour plus d'informations sur les différentes classes et méthodes, reportez-vous à Référence d'API du kit SDK Python Oracle NoSQL.
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ée à une table qui partage la même partie de clé de partage de leurs clés primaires qu'une seule opération d'écriture atomique à l'aide de la classe WriteMultipleRequest. Vous pouvez également ajouter simultanément des données à une table parent et enfant à l'aide de la classe WriteMultipleRequest. Il s'agit d'un moyen efficace de modifier atomiquement plusieurs lignes associées.
Pour plus d'informations sur les différentes classes et méthodes, reportez-vous à Référence d'API du kit SDK Go Oracle NoSQL.
//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 de leurs clés primaires qu'une seule opération d'écriture atomique à l'aide de la méthode writeMany. Vous pouvez également ajouter simultanément des données à une table parent et enfant à l'aide de la méthode writeMany. Il s'agit d'un moyen efficace de modifier atomiquement plusieurs lignes associées.
Pour plus d'informations sur les méthodes, reportez-vous à la classe NoSQLClient.
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);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 de leurs clés primaires qu'une seule opération d'écriture atomique à l'aide de la méthode PutManyAsync. Vous pouvez également ajouter simultanément des données à une table parent et enfant à l'aide de la méthode PutManyAsync. Il s'agit d'un moyen efficace de modifier atomiquement plusieurs lignes associées.
Pour plus d'informations sur toutes les classes et méthodes, reportez-vous à Référence d'API du kit SDK Dotnet Oracle NoSQL.
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)
);
}
Utiliser des API pour ajouter des données à des tables