1. Copy the code given below to an editor of your choice. You use this program to connect to Oracle NoSQL Database Cloud Service and create a simple NOSQL Table.

   You can access the online godoc to reference Go classes, types, and methods included in this sample application.

   package main
   
   import (
     "fmt"
     "time"
   
     "github.com/oracle/nosql-go-sdk/nosqldb"
     "github.com/oracle/nosql-go-sdk/nosqldb/auth/iam"
     "github.com/oracle/nosql-go-sdk/nosqldb/jsonutil"
     "github.com/oracle/nosql-go-sdk/nosqldb/types"
     "github.com/oracle/nosql-go-sdk/nosqldb/httputil"
   )
   
   // createClient creates a client with the supplied configurations.
   
   func createClient() (*nosqldb.Client, error) {
   
       var cfg nosqldb.Config
     
       // This program demonstrates two approaches for supplying configurations
       // for cloud service.
       //
       //   1. Directly in this program.
       //   2. Use a configuration file.
       //
       // If you use the second approach, set "useConfigFile" to true.
       useConfigFile := false
   
       // Set desired region id for NoSQL cloud service. e.g. us-ashburn-1
       region := "<your region ID>"
   
       // Set desired compartment name or id.
       // Set to an empty string to use the default compartment, that is
       // the root compartment of the tenancy.
       // If using a nested compartment, specify the full compartment path
       // relative to the root compartment as compartmentID.
       // For example, if using rootCompartment.compartmentA.compartmentB, the
       // compartmentID should be set to compartmentA.compartmentB.
       // Alternatively you can use the compartment OCID as the
       // string value.
       compartmentID := "<your compartment ID>"
   
       if !useConfigFile {
         // Set the following information accordingly:
         //
         //   tenancy OCID
         //   user OCID
         //   fingerprint of your public key
         //   your private key file or private key content
         //   passphrase of your private key
         //
         tenancy := "<your tenancy OCID>"
         user := "<your user OCID>"
         fingerprint := "<fingerprint of your public key>"
         privateKey := "<full path to your private key file>"
         // If passphrase is not required, use an empty string
         privateKeyPassphrase := "<optional passphrase>"
   
         sp, err := iam.NewRawSignatureProvider(tenancy, user, region, fingerprint,
           compartmentID, privateKey, &privateKeyPassphrase)
         if err != nil {
           return nil, fmt.Errorf("cannot create a Signature Provider: %v", err)
         }
   
         cfg = nosqldb.Config{
           Region:                nosqldb.Region(region),
           AuthorizationProvider: sp,
         }
   
       } else {
         // Modify and save the following content into the
         // configuration file $HOME/.oci/config.
         //
         // [DEFAULT]
         // tenancy=<your tenancy OCID>
         // user=<your user OCID>
         // fingerprint=<fingerprint of your public key>
         // key_file=<full path to your private key file>
         // pass_phrase=<optional passphrase>
         //
         sp, err := iam.NewSignatureProviderFromFile("~/.oci/config", "", "", compartmentID)
         if err != nil {
           return nil, fmt.Errorf("cannot create a Signature Provider: %v", err)
         }
         cfg = nosqldb.Config{
           Mode:                  "cloud",
           Region:                nosqldb.Region(region),
           AuthorizationProvider: sp,
           
           HTTPConfig: httputil.HTTPConfig{
             InsecureSkipVerify: true,
           },
         }
       }
   
     client, err := nosqldb.NewClient(cfg)
     return client, err
   }
   
   func main() {
     client, err := createClient()
     if err != nil {
       fmt.Printf("cannot create NoSQL client: %v\n", err)
       return
     }
     defer client.Close()
   
     // Creates a simple table with a LONG key and a single STRING field.
     tableName := "go_quick_start"
     stmt := fmt.Sprintf("CREATE TABLE IF NOT EXISTS %s ("+
       "id LONG, "+
       "test_data STRING, "+
       "PRIMARY KEY(id))",
       tableName)
     tableReq := &nosqldb.TableRequest{
       Statement: stmt,
       TableLimits: &nosqldb.TableLimits{
         ReadUnits:  50,
         WriteUnits: 50,
         StorageGB:  2,
       },
     }
     tableRes, err := client.DoTableRequest(tableReq)
     if err != nil {
       fmt.Printf("cannot initiate CREATE TABLE request: %v\n", err)
       return
     }
   
     // The create table request is asynchronous, wait for table creation to complete.
     _, 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)
   
     // put a simple set of string data
     mapVals := types.ToMapValue("id", 12345)
     mapVals.Put("test_data", "This is a sample string of test data")
     putReq := &nosqldb.PutRequest{
       TableName: tableName,
       Value:     mapVals,
     }
     putRes, err := client.Put(putReq)
     if err != nil {
       fmt.Printf("failed to put single row: %v\n", err)
       return
     }
     fmt.Printf("Put row: %v\nresult: %v\n", putReq.Value.Map(), putRes)
   
     // get data back
     key := &types.MapValue{}
     key.Put("id", 12345)
     getReq := &nosqldb.GetRequest{
       TableName: tableName,
       Key:       key,
     }
     getRes, err := client.Get(getReq)
     if err != nil {
       fmt.Printf("failed to get single row: %v\n", err)
       return
     }
   
     if getRes.RowExists() {
       fmt.Printf("Got row: %v\n", getRes.ValueAsJSON())
     } else {
       fmt.Printf("The row does not exist.\n")
     }
   
     // Delete the row
     delReq := &nosqldb.DeleteRequest{
       TableName: tableName,
       Key:       key,
     }
     delRes, err := client.Delete(delReq)
     if err != nil {
       fmt.Printf("failed to delete single row: %v\n", err)
       return
     }
   
     if delRes.Success {
       fmt.Printf("Deleted key: %v\nresult: %v\n", jsonutil.AsJSON(delReq.Key.Map()), delRes)
     }
   
     // Drop the table
     dropReq := &nosqldb.TableRequest{
       Statement: "DROP TABLE IF EXISTS " + tableName,
     }
     tableRes, err = client.DoTableRequestAndWait(dropReq, 60*time.Second, time.Second)
     if err != nil {
       fmt.Printf("failed to drop table: %v\n", err)
       return
     }
     fmt.Println("Dropped table ", tableName) }
   

2. Set the following values under case "cloud": in the createClient function:
   • Region identifier
   • Optional compartment ID
   • OCID of the tenancy.
   • OCID of the user calling the API.
   • Fingerprint for the key pair being used.
   • Full path and filename of the private key.
   • The passphrase used for the key, if it is encrypted. This should be a character array.

3. Create a directory quickstart, and save the example program as quickstart.go in the directory.

Alternatively, instead of hard coding OCID, fingerprint & key credentials in the program, you can add this information in the Oracle Cloud Infrastructure configuration file and add that configuration file in the quickstart.go program.

Note: This section is required only if you want to execute the example using OCI credential file. Else, you can skip this section and go to the Execute the Sample Application section.

1. Create a directory named ~/.oci.
2. Create an OCI configuration file named config and place it in the above directory.

   Note: The default configuration file name and location should be always ~/.oci/config .

3. Open the config file and add the following code in it, and replace the placeholder values with actual values.

   [DEFAULT]
   tenancy=ocid1.tenancy.oc1..<unique_ID>
   user=ocid1.user.oc1..<unique_ID>
   fingerprint=<fingerprint of your public key>
   key_file=~/.oci/oci_api_key.pem
   pass_phrase=<optional passphrase>

   Note: This is the DEFAULT profile. The OCI configuration file can contain several profiles.

4. Update the details in the config file with the following values.
• OCID of the tenancy.
• OCID of the user calling the API.
• Fingerprint for the key pair being used.
• Full path and filename of the private key.
• The passphrase used for the key, if it is encrypted.
5. In the quickstart.go program, set the flag useConfigFile to true, under case "cloud"

    useConfigFile := true

6. Provide appropriate parameters for iam.NewSignatureProviderFromFile method:
   • If using the DEFAULT profile with the config file in default location ~/.oci/config.

       sp, err := iam.NewSignatureProviderFromFile("~/.oci/config", "", "", compartmentID)
                           

   • If using non-default profile TEST with the config file in default location ~/.oci/config.

       sp, err := iam.NewSignatureProviderFromFile("~/.oci/config", "TEST", "", compartmentID)
                             

   • If using non-default profile DEV with the config file at non-default location such as /home/users/config

       sp, err := iam.NewSignatureProviderFromFile("/home/users/config", "DEV", "", compartmentID)
                             

7. Save the quickstart.go program.

1. Open the Command Prompt.
2. Initialize a new module for the example program.

   go mod init example.com/quickstart

3. Build the quickstart application.

   go build -o quickstart

4. Run the quickstart application.

   ./quickstart

   Expected Output:

   Created table  go_quick_start
   Put row: map[id:12345 test_data:This is a sample string of test data]
   result: {"readKB":0,"writeKB":1,"readUnits":0,"existingVersion":null,"existingValue":null,"version":"rO0ABXcsABU0XG/CPt1KFpeLA0xx6KY/AAAAAC9lq0cBAwAAAAsAAAABAAAEjAV5Rpc=","generatedValue":null}
   Got row: {"id":12345,"test_data":"This is a sample string of test data"}
   Deleted key: {"id":12345}
   result: {"readKB":1,"writeKB":1,"readUnits":2,"existingVersion":null,"existingValue":null,"success":true}
   Dropped table  go_quick_start