pip3 install borneo

• En sistemas Windows, abra el archivo MSI que descargó y siga las indicaciones para instalar Go.
• En sistemas Linux, extraiga el archivo descargado en /usr/local y cree un árbol Go en /usr/local/go. Agregue /usr/local/go/bin a la variable de entorno PATH.

npm install oracle-nosqldb

• Agregue el SDK como referencia de proyecto: puede agregar el paquete NuGet del SDK como referencia al proyecto mediante la CLI de .Net.

  cd <your-project-directory>
  dotnet add package Oracle.NoSQL.SDK

  También puede realizar la misma acción con NuGet Package Manager en Visual Studio.
• Instalación independiente: puede instalar el SDK de forma independiente en el directorio que desee mediante la CLI nuget.exe.

  nuget.exe install Oracle.NoSQL.SDK -OutputDirectory
  <your-packages-directory>

<dependency>
    <groupId>com.oracle.nosql.sdk</groupId>
    <artifactId>spring-data-oracle-nosql</artifactId>
    <version>1.4.1</version>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <version>2.7.0</version>
</dependency>

from borneo import NoSQLHandle, NoSQLHandleConfig, Regions
from borneo.iam import SignatureProvider
# create AuthorizationProvider
provider = SignatureProvider()
# create handle config using the correct desired region
# as endpoint, add a default compartment.
config = NoSQLHandleConfig(Regions.US_ASHBURN_1).
set_authorization_provider(provider).
set_default_compartment('mycompartment')
# create the handle
handle = NoSQLHandle(config)

provider, err := iam.NewSignatureProviderFromFile(cfgfile, profile, passphrase, compartment)
cfg := nosqldb.Config
{ 
   Region: "us-phoenix-1", AuthorizationProvider: provider,
}
client, err := nosqldb.NewClient(cfg)
// use client for all NoSQL DB operations

const NoSQLClient = require('oracle-nosqldb').NoSQLClient;

let client = new NoSQLClient({
    region: Region.US_ASHBURN_1,
    timeout: 20000,
    ddlTimeout: 40000,
    compartment: 'mycompartment',
    auth: {
        iam: {
            configFile: '~/myapp/.oci/config',
            profileName: 'Jane'
        }
    }
});

{ 
"region": "US_ASHBURN_1",
 "timeout": 20000,
 "ddlTimeout": 40000,
 "compartment": "mycompartment", 
 "auth": { 
    "iam": { 
       "configFile": "~/myapp/.oci/config",
       "profileName": "Jane"
    } 
  }
}

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

var client = new NoSQLClient(
    new NoSQLConfig
    {
        Region = Region.US_ASHBURN_1,
        Timeout = TimeSpan.FromSeconds(10),
        TableDDLTimeout = TimeSpan.FromSeconds(20),
        Compartment = "mycompartment",
        AuthorizationProvider = new IAMAuthorizationProvider(
            "~/myapp/.oci/config", "Jane")
    });

{
    "Region": "us-ashburn-1",
    "Timeout": 20000,
    "TableDDLTimeout": 40000,
    "compartment": "mycompartment",
    "AuthorizationProvider":
    {
        "AuthorizationType": "IAM",
        "ConfigFile": "~/myapp/.oci/config",
        "ProfileName": "Jane"
    }
}

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

import com.oracle.nosql.spring.data.config.AbstractNosqlConfiguration;
import com.oracle.nosql.spring.data.config.NosqlDbConfig;
import com.oracle.nosql.spring.data.repository.config.EnableNosqlRepositories;
 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
import oracle.nosql.driver.kv.StoreAccessTokenProvider;
 
import oracle.nosql.driver.Region;
import oracle.nosql.driver.iam.SignatureProvider;
import java.io.File;
 
public class AppConfig extends AbstractNosqlConfiguration
 
{
    /* Annotation to tell the Spring Data Framework that the returned object should be registered as a bean in the Spring application.*/
    @Bean
    public NosqlDbConfig nosqlDbConfig()
    {
        SignatureProvider signatureProvider;
        char passphrase[] = < Pass phrase > ; //Optional. A passphrase for the key, if it is encrypted.
 
        /* Details that are required to authenticate and authorize access to the Oracle NoSQL Database Cloud Service are provided.*/
        signatureProvider = new SignatureProvider(
            < tenantID > , //The Oracle Cloud Identifier (OCID) of the tenancy.
            < userID > , //The Oracle Cloud Identifier (OCID) of a user in the tenancy.
            < fingerprint > , //The fingerprint of the key pair used for signing.
            new File( < privateKeyFile > ), //Full path to the key file.
            passphrase //Optional.
        );
 
        /* Provide the service URL of the Oracle NoSQL Database Cloud Service and update the Region.<Region name>.endpoint() with the appropriate value.
           For example, Region.US_ASHBURN_1.endpoint() .*/
 
        return new NosqlDbConfig(Region. < Region name > .endpoint(), signatureProvider);
    }

• Existe un método para permitir la especificación de un compartimento por defecto para las solicitudes en borneo.NoSQLHandleConfig.set_compartment(). Esto sustituye el compartimento por defecto del usuario.
• Además, es posible especificar un compartimento en cada instancia Request.

...
request = PutRequest().set_table_name('mycompartment:mytable')
...
create_statement = 'create table mycompartment:mytable(...)' 
...
request = GetRequest().set_table_name('compartmentA.compartmentB')

• Puede definir un nombre o ID de compartimento deseado.
• Se define en una cadena vacía para utilizar el compartimento por defecto, es decir, el compartimento raíz del arrendamiento.
• Si utiliza un compartimento anidado, especifique la ruta de compartimento completa relativa al compartimento raíz como compartmentID. Por ejemplo, si se utiliza rootCompartment.compartmentA.compartmentB, compartmentID se debe definir en compartmentA.compartmentB.
• También puede utilizar el OCID de compartimento como valor de cadena.

compartmentID:="<optional-compartment-name-or-ID>"
iam.NewRawSignatureProvider(tenancy, user, region, fingerprint, compartmentID,
        privateKey, &privateKeyPassphrase)

const NoSQLClient = require('oracle-nosqldb').NoSQLClient;
const client = new NoSQLClient({
    region: Region.US_ASHBURN_1,
    compartment: 'mycompartment'
});

var client = new NoSQLClient(
    new NoSQLConfig
    {
        Region=Region.US_ASHBURN_1,
        Compartment="<compartment_ocid_or_name>"
    });

#Create a simple table with an integer key and a single 
#json data field and set your desired table capacity. 
#Set the table TTL value to 3 days.
from borneo import TableLimits,
TableRequest statement = 'create table if not exists users(id integer, 
                                              name string,
                                              ' + 'primary key(id) 
                                                 USING TTL 3 DAYS'

# In the Cloud Service TableLimits is a required object for table 
#creation. It specifies the throughput and capacity for the table in 
#ReadUnits,  WriteUnits, GB
# Call the appropriate constructor for 
# 1) Provisioned Capacity
# TableLimits(50, 50, 25);
#  2) On-demand Capacity - only set storage limit
# TableLimits( 25 );  
# In this example, we will use Provisioned Capacity 
request = TableRequest().set_statement(statement).
                        set_table_limits( TableLimits(50, 50, 25))

# assume that a handle has been created, as handle, make the request 
#wait for 60 seconds, polling every 1 seconds
result = handle.do_table_request(request, 60000, 1000) 
# the above call to do_table_request is equivalent to 
# result = handle.table_request(request)
result.wait_for_completion(handle, 60000, 1000)

#Create an index called nameIdx on the name field in the users table.
request = TableRequest().set_statement("CREATE INDEX IF NOT EXISTS nameIdx 
                                        ON users(name)")
# assume that a handle has been created, as handle, make the request 
#wait for 60 seconds, polling every 1 seconds
result = handle.do_table_request(request, 60000, 1000) 
# the above call to do_table_request is equivalent to
# result = handle.table_request(request) 
result.wait_for_completion(handle, 60000, 1000)

ltr = ListTablesRequest()
list(str)= handle.list_tables(ltr).getTables()
if list(str).len() = 0 
   print ("No tables available")
else 
   print('The tables available are: ' + list(str))

request = GetTableRequest().set_table_name(table_name)
result = handle.get_table(request)
print('The schema details for the table is: ' + result.get_schema())

// Create a simple table with an integer key and a single
// json data field and set your desired table capacity.
// Set the table TTL value to 3 days.
tableName := "users"
stmt := fmt.Sprintf("CREATE TABLE IF NOT EXISTS %s "+
    "(id integer, name STRING, PRIMARY KEY(id) "+
    "USING TTL 3 DAYS)", tableName)

// Call the appropriate constructor for
// 1) Provisioned Capacity
// &nosqldb.TableLimits(ReadUnits: 50, WriteUnits: 50, StorageGB: 25);
// 2) On-demand Capacity - only set storage limit
// &nosqldb.TableLimits(StorageGB: 25 );   
// In this example, we will use Provisioned Capacity
tableReq := &nosqldb.TableRequest{
    Statement: stmt,
    TableLimits: &nosqldb.TableLimits{
        ReadUnits:  50,
        WriteUnits: 50,
        StorageGB:  25,
    },
}

tableRes, err := client.DoTableRequest(tableReq)
if err != nil {
    fmt.Printf("cannot initiate CREATE TABLE request: %v\n", err)
    return
}
_, err = tableRes.WaitForCompletion(client, 60*time.Second, time.Second)
if err != nil {
    fmt.Printf("Error finishing CREATE TABLE request: %v\n", err)
    return
}
fmt.Println("Created table ", tableName)

//Create an index called nameIdx on the name field in the users table
stmt_ind := fmt.Sprintf("CREATE INDEX IF NOT EXISTS nameIdx ON users(name)")
tableReq := &nosqldb.TableRequest{Statement: stmt_ind}
tableRes, err := client.DoTableRequest(tableReq)
if err != nil {
    fmt.Printf("cannot initiate CREATE INDEX request: %v\n", err)
    return
}
_, err = tableRes.WaitForCompletion(client, 60*time.Second, time.Second)
if err != nil {
    fmt.Printf("Error finishing CREATE INDEX request: %v\n", err)
    return
}
fmt.Println("Created index nameIdx ")

req := &nosqldb.ListTablesRequest{Timeout: 3 * time.Second,}
res, err := client.ListTables(req)
if len(res.Tables)== 0{
   fmt.Printf("No tables in the given compartment"
   return
}
fmt.Printf("The tables in the given compartment are:\n" )
for i, table := range res.Tables {
   fmt.Printf(table)
}

req := &nosqldb.GetTableRequest{
TableName: table_name, Timeout: 3 * time.Second, }
res, err := client.GetTable(req)
fmt.Printf("The schema details for the table is:state=%s, 
   limits=%v\n", res.State,res.Limits)

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

async function createUsersTable() {
    try {
        const statement = 'CREATE TABLE IF NOT EXISTS users(id INTEGER, ' +
            'name STRING, PRIMARY KEY(id))';

// Call the appropriate constructor for
// 1) Provisioned Capacity
//  tableLimits: {readUnits: 50, writeUnits: 50, storageGB: 25);
// 2) On-demand Capacity - only set storage limit
//  tableLimits: {storageGB: 25 );   
// In this example, we will use Provisioned Capacity
        let result = await client.tableDDL(statement, {
            tableLimits: {
                readUnits: 50,
                writeUnits: 50,
                storageGB: 25
            }
        });

        result = await client.forCompletion(result);
        console.log('Table users created');
    } catch(error) {
        //handle errors
    }
}

const statement = 'CREATE TABLE IF NOT EXISTS users(id INTEGER, ' +
        'name STRING, PRIMARY KEY(id))';

// Call the appropriate constructor for
// 1) Provisioned Capacity
//  tableLimits: {readUnits: 50, writeUnits: 50, storageGB: 25);
// 2) On-demand Capacity - only set storage limit
//  tableLimits: {storageGB: 25 );   
// In this example, we will use Provisioned Capacity
        let result = await client.tableDDL(statement, {
        tableLimits: {
            readUnits: 50,
            writeUnits: 50,
            storageGB: 25
        },
        complete: true
    });

    console.log('Table users created');

// Create an index called nameIdx on the name field in the users table.
try {
   const statement = 'CREATE INDEX IF NOT EXISTS nameIdx ON users(name))';
   let result = await client.tableDDL(statement);
   result = await client.forCompletion(result);
   console.log('Index nameIdx created');
} catch(error){
  //handle errors 
}

let varListTablesResult = await client.listTables();
console.log("The tables in the given compartment are:")
{res.send(varListTablesResult)}

let resExistingTab = await client.getTable(tablename);
{ await client.forCompletion(resExistingTab);}
console.log("The  schema details for the table is:")
{ res.send(resExistingTab.schema)}

var client = new NoSQLClient("config.json");
try { 
  var statement = "CREATE TABLE IF NOT EXISTS users(id INTEGER,"
    + "name STRING, PRIMARY KEY(id))";

// Call the appropriate constructor for
// 1) Provisioned Capacity
// new TableLimits(50, 50, 25);
// 2) On-demand Capacity - only set storage limit
// new TableLimits( 25 );   
// In this example, we will use Provisioned Capacity
  var result = await client.ExecuteTableDDLAsync(statement, new
    TableLimits(50, 50, 25)); 

  await result.WaitForCompletionAsync(); 
  Console.WriteLine("Table users created."); 
} catch(Exception ex) {
   // handle exceptions
}

var statement = "CREATE TABLE IF NOT EXISTS users(id INTEGER,"
    + "name STRING, PRIMARY KEY(id))"; 

// Call the appropriate constructor for
// 1) Provisioned Capacity
// new TableLimits(50, 50, 25);
// 2) On-demand Capacity - only set storage limit
// new TableLimits(25 );   
// In this example, we will use Provisioned Capacity
await client.ExecuteTableDDLWithCompletionAsync(statement, 
       new  TableLimits(50, 50, 25)); 

Console.WriteLine("Table users created.");

varresult = await client.ListTablesAsync(); 
console.WriteLine("The tables in the given compartment are:") 
foreach(var tableName inresult.TableNames){
   Console.WriteLine(tableName);
}

import com.oracle.nosql.spring.data.core.mapping.NosqlId;
import com.oracle.nosql.spring.data.core.mapping.NosqlTable;
 
/* Set the TableLimits. */
@NosqlTable(readUnits = 50, writeUnits = 50, storageGB = 25)
 
public class Users
{
    @NosqlId(generated = true)
    long id;
    String firstName;
    String lastName;
 
    /* public or package protected constructor required when retrieving from the database. */
    public Users() {
    }
 
    @Override
    public String toString()
    {
        return "Users{" +
            "id=" + id + ", " +
            "firstName=" + firstName + ", " +
            "lastName=" + lastName +
            '}';
    }
}

import com.oracle.nosql.spring.data.repository.NosqlRepository;
 
/* The Users is the entity class and Long is the data type of the primary key in the Users class.
   This interface provides methods that return iterable instances of  the Users class. */
 
public interface UsersRepository extends NosqlRepository<Users, Long> {
    /* Search the Users table by the last name and return an iterable instance of the Users class.*/
    Iterable<Users> findByLastName(String lastname);
}

import com.oracle.nosql.spring.data.core.NosqlTemplate;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
 
/* The @SpringBootApplication annotation helps you to build an application using Spring Data Framework rapidly.*/
@SpringBootApplication
public class App implements CommandLineRunner {
 
    /* The annotation enables Spring Data Framework to look up the configuration file for a matching bean.*/
    @Autowired
    private UsersRepository repo;
 
    public static void main(String[] args) {
        ConfigurableApplicationContext ctx =
                SpringApplication.run(App.class, args);
        SpringApplication.exit(ctx, () -> 0);
        ctx.close();
        System.exit(0);
    }
 
    @Override
    public void run(String... args) throws Exception {
    }
}

import com.oracle.nosql.spring.data.core.NosqlTemplate;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
 
/* Create an Index on the lastName field of the Users Table. */
 
try {
    AppConfig config = new AppConfig();
    NosqlTemplate idx = NosqlTemplate.create(config.nosqlDbConfig());
    idx.runTableRequest("CREATE INDEX IF NOT EXISTS nameIdx ON Users(kv_json_.lastName AS STRING)");
    System.out.println("Index created successfully");
} catch (Exception e) {
    System.out.println("Exception creating index" + e);
}