Go SDK: Migrate from V1 to V2

1
var bearerToken = ""
2
3
func GetSkyflowBearerToken() (string, error) {
4
    filePath := "<file_path>"
5
    if saUtil.IsExpired(bearerToken) {
6
        newToken, err := saUtil.GenerateBearerToken(filePath)
7
        if err != nil {
8
            return "", err
9
        }
10
        bearerToken = newToken.AccessToken
11
        return bearerToken, nil
12
    }
13
    return bearerToken, nil
14
}

1
// Option 1: API key (recommended)
2
skyflowCredentials := common.Credentials{ApiKey: "<YOUR_API_KEY>"}
3
4
// Option 2: Environment variable — set SKYFLOW_CREDENTIALS in your environment
5
6
// Option 3: Credentials file
7
skyflowCredentials := common.Credentials{Path: "<YOUR_CREDENTIALS_FILE_PATH>"}
8
9
// Option 4: Stringified JSON
10
skyflowCredentials := common.Credentials{CredentialsString: "<YOUR_CREDENTIALS_STRING>"}
11
12
// Option 5: Bearer token
13
skyflowCredentials := common.Credentials{Token: "<BEARER_TOKEN>"}

1
import (
2
    Skyflow "github.com/skyflowapi/skyflow-go/skyflow/client"
3
    "github.com/skyflowapi/skyflow-go/skyflow/common"
4
)
5
6
configuration := common.Configuration{
7
    VaultID:       "<vault_id>",
8
    VaultURL:      "<vault_url>",
9
    TokenProvider: GetToken,
10
}
11
skyflowClient := Skyflow.Init(configuration)

1
import (
2
    "context"
3
    "fmt"
4
5
    "github.com/skyflowapi/skyflow-go/v2/client"
6
    "github.com/skyflowapi/skyflow-go/v2/utils/common"
7
    "github.com/skyflowapi/skyflow-go/v2/utils/logger"
8
)
9
10
creds := common.Credentials{Path: "<YOUR_CREDENTIALS_FILE_PATH>"}
11
12
vaultConfig := common.VaultConfig{
13
    VaultId:     "<VAULT_ID>",
14
    ClusterId:   "<CLUSTER_ID>",
15
    Env:         common.PROD,
16
    Credentials: creds,
17
}
18
19
skyflowClient, err := client.NewSkyflow(
20
    client.WithVaults(vaultConfig),
21
    client.WithLogLevel(logger.INFO),
22
)
23
if err != nil {
24
    fmt.Println(err)
25
    return
26
}

1
primaryConfig := common.VaultConfig{
2
    VaultId:     "<PRIMARY_VAULT_ID>",
3
    ClusterId:   "<PRIMARY_CLUSTER_ID>",
4
    Env:         common.PROD,
5
    Credentials: primaryCreds,
6
}
7
8
secondaryConfig := common.VaultConfig{
9
    VaultId:     "<SECONDARY_VAULT_ID>",
10
    ClusterId:   "<SECONDARY_CLUSTER_ID>",
11
    Env:         common.PROD,
12
    Credentials: secondaryCreds,
13
}
14
15
skyflowClient, err := client.NewSkyflow(
16
    client.WithVaults(primaryConfig, secondaryConfig),
17
    client.WithLogLevel(logger.INFO),
18
)
19
if err != nil {
20
    fmt.Println(err)
21
    return
22
}

1
var records = make(map[string]interface{})
2
var record = make(map[string]interface{})
3
record["table"] = "<your_table_name>"
4
fields := map[string]interface{}{"<field_name>": "<field_value>"}
5
record["fields"] = fields
6
records["records"] = []interface{}{record}
7
8
options := common.InsertOptions{
9
    Tokens:          true,
10
    ContinueOnError: true,
11
}
12
res, err := skyflowClient.Insert(records, options)

1
service, err := skyflowClient.Vault("<VAULT_ID>")
2
if err != nil {
3
    fmt.Println(err)
4
    return
5
}
6
7
ctx := context.TODO()
8
9
values := []map[string]interface{}{
10
    {"<COLUMN_NAME>": "<COLUMN_VALUE>"},
11
}
12
13
insert, err := service.Insert(ctx, common.InsertRequest{
14
    Table:  "<TABLE_NAME>",
15
    Values: values,
16
}, common.InsertOptions{
17
    ContinueOnError: false,
18
    ReturnTokens:    true,
19
})
20
if err != nil {
21
    fmt.Println("Error occurred ", *err)
22
    return
23
}
24
fmt.Println("RESPONSE:", insert)

1
get, err := service.Get(ctx, common.GetRequest{
2
    Table: "<TABLE_NAME>",
3
    Ids:   []string{"<SKYFLOW_ID_1>", "<SKYFLOW_ID_2>"},
4
}, common.GetOptions{ReturnTokens: true})
5
if err != nil {
6
    fmt.Println("Error occurred ", *err)
7
    return
8
}
9
fmt.Println(get)

1
update, err := service.Update(ctx, common.UpdateRequest{
2
    Table: "<TABLE_NAME>",
3
    Data: map[string]interface{}{
4
        "skyflow_id":  "<SKYFLOW_ID>",
5
        "card_number": "<NEW_VALUE>",
6
    },
7
}, common.UpdateOptions{ReturnTokens: true})
8
if err != nil {
9
    fmt.Println("Error occurred ", *err)
10
    return
11
}
12
fmt.Println(update)

1
del, err := service.Delete(ctx, common.DeleteRequest{
2
    Table: "<TABLE_NAME>",
3
    Ids:   []string{"<SKYFLOW_ID_1>", "<SKYFLOW_ID_2>"},
4
})
5
if err != nil {
6
    fmt.Println("Error occurred ", *err)
7
    return
8
}
9
fmt.Println(del)

1
detokenize, err := service.Detokenize(ctx, common.DetokenizeRequest{
2
    Tokens: []string{"<TOKEN_1>", "<TOKEN_2>"},
3
})
4
if err != nil {
5
    fmt.Println("Error occurred ", *err)
6
    return
7
}
8
fmt.Println(detokenize)

1
query, err := service.Query(ctx, common.QueryRequest{
2
    Query: `SELECT * FROM <TABLE_NAME> WHERE skyflow_id = "<SKYFLOW_ID>"`,
3
})
4
if err != nil {
5
    fmt.Println("Error occurred ", *err)
6
    return
7
}
8
fmt.Println(query)

1
options := common.InsertOptions{
2
    Tokens:          true,
3
    Upsert:          upsertArray,
4
    ContinueOnError: true,
5
}

1
options := common.InsertOptions{
2
    ContinueOnError: false,
3
    ReturnTokens:    true,
4
    TokenMode:       common.DISABLE,
5
    Upsert:          "<UPSERT_COLUMN>",
6
}