Go client internals

package main

import (
	"context"
	"log"
	"time"

	"github.com/datastax/astra-db-go/v2/astra"
	"github.com/datastax/astra-db-go/v2/astra/filter"
	"github.com/datastax/astra-db-go/v2/astra/options"
)

func main() {
	ctx := context.Background()

	// Set the general method timeout and table admin timeout
	// for any structs spawned from this client struct
	client := astra.NewClient(
		options.API().
			SetEnvironment(options.EnvironmentHCD).
			SetGeneralMethodTimeout(10 * time.Second).
			SetTableAdminTimeout(40 * time.Second),
	)

	// Override the general method timeout
	// and set the keyspace admin timeout
	// for any structs spawned from this Db struct
	// and for any methods called by this struct
	database := client.Database(
		"API_ENDPOINT",
		options.API().
			SetUsernamePasswordTokenProvider(
				"USERNAME",
				"PASSWORD",
			).
			SetGeneralMethodTimeout(5*time.Second).
			SetKeyspaceAdminTimeout(20*time.Second),
	)

	// Override the general method timeout
	// and set the request admin timeout
	// for any structs spawned from this Db struct
	// and for any methods called by this struct
	table := database.Table(
		"TABLE_NAME",
		options.GetTable().
			UpdateAPIOptions(options.API().
				SetGeneralMethodTimeout(15*time.Second).
				SetRequestTimeout(7*time.Second),
			),
	)

	// Override the request timeout for this method
	var result astra.Row
	err := table.FindOne(
		ctx,
		filter.Lt("number_of_pages", 300),
		options.TableFindOne().
			UpdateAPIOptions(options.API().SetRequestTimeout(5*time.Second)),
	).Decode(&result)

	if err != nil {
		log.Fatal(err)
	}
}

package main

import (
	"context"
	"errors"
	"fmt"

	"github.com/datastax/astra-db-go/v2/astra"
	"github.com/datastax/astra-db-go/v2/astra/options"
	"github.com/datastax/astra-db-go/v2/astra/results"
)

func main() {
	ctx := context.Background()
	client := astra.NewClient(
		options.API().SetEnvironment(options.EnvironmentHCD),
	)

	database := client.Database(
		"API_ENDPOINT",
		options.API().
			SetUsernamePasswordTokenProvider(
			"USERNAME",
			"PASSWORD",
		).
			SetKeyspace("KEYSPACE_NAME"),
	)

	collection := database.Collection("COLLECTION_NAME")

	documents := []map[string]any{
		{"_id": "123", "value": 1},
		{"_id": "123", "value": 2}, // Duplicate _id
		{"_id": "456", "value": 3},
	}
	_, err := collection.InsertMany(
		ctx,
		documents,
		options.CollectionInsertMany().SetOrdered(false),
	)
	if err == nil {
		return
	}

	var insertManyErr *results.InsertManyError
	var apiErrs *results.DataAPIErrors
	switch {
	case errors.As(err, &insertManyErr):
		var insertedIDs []string
		if decodeErr := insertManyErr.DecodeIDs(
			&insertedIDs,
		); decodeErr != nil {
			fmt.Printf("Failed to decode inserted IDs: %v\n", decodeErr)
		}
		if insertManyErr.InsertedCount() > 0 {
			fmt.Printf(
				"Successfully inserted %d document(s): %v\n",
				insertManyErr.InsertedCount(),
				insertedIDs,
			)
		}
		for _, apiErr := range insertManyErr.Errors {
			fmt.Printf(
				"Error reported: %s - %s\n",
				apiErr.ErrorCode,
				apiErr.Message,
			)
		}
	case errors.As(err, &apiErrs):
		fmt.Println("API command failed:")
		for _, apiErr := range *apiErrs {
			fmt.Printf("  Code: %s\n", apiErr.ErrorCode)
			fmt.Printf("  Message: %s\n", apiErr.Message)
		}
	case errors.Is(err, context.DeadlineExceeded):
		fmt.Printf("Timed out: %v\n", err)
	default:
		fmt.Printf("Other error: %v\n", err)
	}
}