The borneo.PutRequest class represents input to the borneo.NoSQLHandle.put() method used to insert single rows. This method can be used for unconditional and conditional puts to:

• Overwrite any existing row. This is the default.
• Succeed only if the row does not exist. Use borneo.PutOption.IF_ABSENT for this case.
• Succeed only if the row exists. Use borneo.PutOption.IF_PRESENT for this case.
• Succeed only if the row exists and its borneo.Version matches a specific borneo.Version. Use borneo.PutOption.IF_VERSION for this case and borneo.PutRequest.set_match_version() to specify the version to match.

from borneo import PutRequest
# PutRequest requires a table name 
request = PutRequest().set_table_name('users')
# set the value 
request.set_value({'id': i, 'name': 'Jane'})
result = handle.put(request)
# a successful put returns a non-empty version
if result.get_version() is not None: 
# success

The data value provided for a row or key is a Python dict. It can be supplied to the relevant requests (GetRequest, PutRequest, DeleteRequest) in multiple ways:

• as a Python dict directly:

  request.set_value({'id': 1})
  request.set_key({'id': 1 })

• as a JSON string:

  request.set_value_from_json('{"id": 1, "name": "Jane"}')
  request.set_key_from_json('{"id": 1}')

The nosqldb.PutRequest represents an input to the nosqldb.Put() function used to insert single rows. This function can be used for unconditional and conditional puts to:

• Overwrite any existing row. This is the default.
• Succeed only if the row does not exist. Specify types.PutIfAbsent for the PutRequest.PutOption field for this case.
• Succeed only if the row exists. Specify types.PutIfPresent for the PutRequest.PutOption field for this case.
• Succeed only if the row exists and its version matches a specific version. Specify types.PutIfVersion for the PutRequest.PutOption field and a desired version for the PutRequest.MatchVersion field for this case.

The data value provided for a row (in PutRequest) or key (in GetRequest and DeleteRequest ) is a *types.MapValue. The key portion of each entry in the MapValue must match the column name of target table, and the value portion must be a valid value for the column. There are several ways to create a MapValue for the row to put into a table:

1. Create an empty MapValue and put values for each column.

   value:=&types.MapValue{}
   value.Put("id", 1).Put("name", "Jack")
   req:=&nosqldb.PutRequest{
       TableName: "users",
       Value: value,
   }
   res, err:=client.Put(req)

2. Create a MapValue from a map[string]interface{}.

   m:=map[string]interface{}{
       "id": 1,
       "name": "Jack",
   }
   value:=types.NewMapValue(m)
   req:=&nosqldb.PutRequest{
       TableName: "users",
       Value: value,
   }
   res, err:=client.Put(req)

3. Create a MapValue from JSON. This is convenient for setting values for a row in the case of a fixed-schema table where the JSON is converted to the target schema. For example:

   value, err:=types.NewMapValueFromJSON(`{"id": 1, "name": "Jack"}`)
   iferr!=nil {
       return
   }
   req:=&nosqldb.PutRequest{
       TableName: "users",
       Value: value,
   }
   res, err:=client.Put(req)

Method put is used to insert a single row into the table. It takes table name, row value as plain JavaScript object and opts as an optional 3rd argument. This method can be used for unconditional and conditional puts to:

• Overwrite existing row with the same primary key if present. This is the default.
• Succeed only if the row with the same primary key does not exist. Specify ifAbsent in the opt argument for this case: { ifAbsent: true }. Alternatively, you may use putIfAbsent method.
• Succeed only if the row with the same primary key exists. Specify ifPresent in the opt argument for this case: { ifPresent: true }. Alternatively, you may use putIfPresent method.
• Succeed only if the row with the same primary key exists and its Version matches a specific Version value. Set matchVersion in the opt argument for this case to the specific version: { matchVersion: my_version }. Alternatively, you may use putIfVersion method and specify the version value as the 3rd argument (after table name and row).

To add rows to your table:

const NoSQLClient = require('oracle-nosqldb').NoSQLClient;
const client = new NoSQLClient('config.json');

async function putRowsIntoUsersTable() {
    const tableName = 'users';
    try {
        // Uncondintional put, should succeed
        let result = await client.put(tableName, { id: 1, name: 'John' });

        // Will fail since the row with the same primary key exists
        result = await client.putIfAbsent(tableName, { id: 1, name: 'Jane' });
        // Expected output: putIfAbsent failed
        console.log('putIfAbsent ' + result.success ? 'succeeded' : 'failed');

        // Will succeed because the row with the same primary key exists
        res = await client.putIfPresent(tableName, { id: 1 , name: 'Jane' });
        // Expected output: putIfAbsent succeeded
        console.log('putIfPresent ' + result.success ?
            'succeeded' : 'failed');

        let version = result.version;
        // Will succeed because the version matches existing row
        result = await client.putIfVersion(tableName, { id: 1, name: 'Kim' },
            version);
        // Expected output: putIfVersion succeeded
        console.log('putIfVersion ' + result.success ? 'succeeded' : 'failed');

        // Will fail because the previous put has changed the row version, so
        // the old version no longer matches.
        result = await client.putIfVersion(tableName, { id: 1, name: 'June' },
            version);
        // Expected output: putIfVersion failed
        console.log('putIfVersion ' + result.success ? 'succeeded' : 'failed');

    } catch(error) {
        //handle errors
    }
}

These methods can be used for unconditional and conditional puts:

• Use PutAsync (without conditional options) to insert a new row or overwrite existing row with the same primary key if present. This is unconditional put.
• Use PutIfAbsentAsync to insert a new row only if the row with the same primary key does not exist.
• Use PutIfPresentAsync to overwrite existing row only if the row with the same primary key exists.
• Use PutIfVersionAsync to overwrite existing row only if the row with the same primary key exists and its RowVersion matches a specific version.

Each of the Put methods above returns Task<PutResult<RecordValue>>. PutResult instance contains info about a completed Put operation, such as success status (conditional put operations may fail if the corresponding condition was not met) and the resulting RowVersion.

To add rows to your table:

var client = new NoSQLClient("config.json");
var tableName = "users";

try {
    // Uncondintional put, should succeed.
    var result = await client.PutAsync(tableName,
        new MapValue
        {
            ["id"] = 1,
            ["name"] = "John"
        });

    // This Put will fail because the row with the same primary
    // key already exists.
    result = await client.PutIfAbsentAsync(tableName,
        new MapValue
        {
            ["id"] = 1,
            ["name"] = "Jane"
        });
    
    // Expected output: PutIfAbsentAsync failed.
    Console.WriteLine("PutIfAbsentAsync {0}.",
        result.Success ? "succeeded" : "failed");

    // This Put will succeed because the row with the same primary
    // key exists.
    result = await client.PutIfPresentAsync(tableName,
        new MapValue
        {
            ["id"] = 1,
            ["name"] = "Jane"
        });

    // Expected output: PutIfPresentAsync succeeded.
    Console.WriteLine("PutIfPresentAsync {0}.",
        result.Success ? "succeeded" : "failed");
    var rowVersion = result.Version;

    // This Put will succeed because the version matches existing
    // row.
    result = await client.PutIfVersionAsync(
        tableName,
        new MapValue
        {
            ["id"] = 1,
            ["name"] = "Kim"
        }),
        rowVersion);

    // Expected output: PutIfVersionAsync succeeded.
    Console.WriteLine("PutIfVersionAsync {0}.",
        result.Success ? "succeeded" : "failed");

    // This Put will fail because the previous Put has changed
    // the row version, so the old version no longer matches.
    result = await client.PutIfVersionAsync(
        tableName,
        new MapValue
        {
            ["id"] = 1,
            ["name"] = "June"
        }),
        rowVersion);

    // Expected output: PutIfVersionAsync failed.
    Console.WriteLine("PutIfVersionAsync {0}.",
        result.Success ? "succeeded" : "failed");

    // Put a new row with TTL indicating expiration in 30 days.
    result = await client.PutAsync(tableName,
        new MapValue
        {
            ["id"] = 2,
            ["name"] = "Jack"
        }),
        new PutOptions
        {
            TTL = TimeToLive.OfDays(30)
        });
}
catch(Exception ex) {
    // handle exceptions
}

In this section, you use the repository.save(entity_object) method to add the rows.

To add rows to your table, you can include the following code in your application.

@Override
public void run(String...args) throws Exception {
 
    /* Create a new User instance and load values into it.*/
 
    Users u1 = new Users();
    u1.firstName = "John";
    u1.lastName = "Doe";
 
    /* Save the User instance.*/
    repo.save(u1);
 
    /* Create a second User instance and load values into it. Save the instance.*/
    Users u2 = new Users();
    u2.firstName = "Angela";
    u2.lastName = "Willard";
 
    repo.save(u2);
}

This creates and saves two user entities. For each entity, the Spring Data SDK creates two columns:

1. Primary key column
2. JSON data type column