---
title: "Get operations"
description: "Guide to Aerospike Go client map retrieval operations including Get by key, range, rank, index, and size."
---

# Get operations

> For the complete documentation index see: [llms.txt](https://aerospike.com/docs/llms.txt)
> 
> All documentation pages available in markdown.

#### `MapGetByKeyOp`: get value by key

Retrieves a value from a map by its key. This is one of the most commonly used map operations.

**Function signature:**

```go
MapGetByKeyOp(binName string, key interface{}, returnType mapReturnType, ctx ...*CDTContext) *Operation
```

**Parameters:**

-   `binName`: Name of the bin containing the map.
-   `key`: The key to look up (string, int64, or interface{} supported type).
-   `returnType`: What to return (see [Return Types](https://aerospike.com/docs/develop/client/go/usage/cdt/reference#map-return-types)).
-   `ctx`: Optional CDT context for nested maps.

**Example: get value (most common)**

```go
// Get a value by key

record, err := client.Operate(nil, key,

    as.MapGetByKeyOp("profile", "email", as.MapReturnType.VALUE),

)

if err != nil {

    log.Fatal(err)

}

email := record.Bins["profile"].(string)

fmt.Println("Email:", email)  // Output: Email: john@example.com
```

**Example: e-commerce product catalog**

```go
// Store product information

product := map[string]any{

    "name":        "Laptop Pro 15",

    "price":       1299.99,

    "stock":       42,

    "category":    "Electronics",

    "description": "High-performance laptop",

}

key, _ := as.NewKey("store", "products", "prod123")

_, err := client.Operate(nil, key,

    as.MapPutItemsOp(as.DefaultMapPolicy(), "product", product),

)

// Later, retrieve product price

record, err := client.Operate(nil, key,

    as.MapGetByKeyOp("product", "price", as.MapReturnType.VALUE),

)

price := record.Bins["product"].(float64)

fmt.Printf("Price: $%.2f\n", price)
```

**Example: check if key exists**

```go
// Check if a key exists

record, err := client.Operate(nil, key,

    as.MapGetByKeyOp("profile", "email", as.MapReturnType.EXISTS),

)

exists := record.Bins["profile"].(bool)

if exists {

    fmt.Println("Email is set")

} else {

    fmt.Println("Email not found")

}
```

**Example: get key-value pair**

```go
// Get both key and value

record, err := client.Operate(nil, key,

    as.MapGetByKeyOp("profile", "name", as.MapReturnType.KEY_VALUE),

)

pairs := record.Bins["profile"].([]as.MapPair)

fmt.Printf("Key: %v, Value: %v\n", pairs[0].Key, pairs[0].Value)
```

**Example: get multiple values in one operation**

```go
// Get multiple values at once

record, err := client.Operate(nil, key,

    as.MapGetByKeyOp("profile", "name", as.MapReturnType.VALUE),

    as.MapGetByKeyOp("profile", "age", as.MapReturnType.VALUE),

    as.MapGetByKeyOp("profile", "email", as.MapReturnType.VALUE),

)

results := record.Bins["profile"].(as.OpResults)

name := results[0].(string)

age := results[1].(int)

email := results[2].(string)

fmt.Printf("Name: %s, Age: %d, Email: %s\n", name, age, email)
```

**Example: working with integer keys**

```go
// Map with integer keys (e.g., user IDs)

scores := map[any]any{

    1001: 1500,

    1002: 2300,

    1003: 1800,

}

key, _ := as.NewKey("game", "scores", "leaderboard")

_, err := client.Operate(nil, key,

    as.MapPutItemsOp(as.DefaultMapPolicy(), "scores", scores),

)

// Get score for user 1002

record, err := client.Operate(nil, key,

    as.MapGetByKeyOp("scores", 1002, as.MapReturnType.VALUE),

)

score := record.Bins["scores"].(int)

fmt.Printf("User 1002 score: %d\n", score)
```

#### `MapGetByKeyListOp`: get multiple values by key list

Retrieves values for multiple keys in a single operation.

```go
// Get multiple values by key list

keys := []any{"name", "email", "age"}

record, err := client.Operate(nil, key,

    as.MapGetByKeyListOp("profile", keys, as.MapReturnType.VALUE),

)

values := record.Bins["profile"].([]any)

// values[0] = name, values[1] = email, values[2] = age
```

#### `MapGetByKeyRangeOp`: get values by key range

Retrieves values for keys within a specified range. Works with ordered maps.

```go
// Get values for keys in range [startKey, endKey)

record, err := client.Operate(nil, key,

    as.MapGetByKeyRangeOp("products", "A", "D", as.MapReturnType.KEY_VALUE),

)

products := record.Bins["products"].([]as.MapPair) // Products with keys A, B, C
```

#### `MapGetByIndexOp`: get by index position

Retrieves a value by its index position in the map (for ordered maps).

```go
// Get first item (index 0)

record, err := client.Operate(nil, key,

    as.MapGetByIndexOp("leaderboard", 0, as.MapReturnType.KEY_VALUE),

)

topPlayers := record.Bins["leaderboard"].([]as.MapPair)

playerAtIndex := topPlayers[0]
```

#### `MapGetByRankOp`: get by value rank

Retrieves a value by its rank (sorted by value). Rank 0 is the smallest value, rank -1 is the largest value (highest rank).

```go
// Get item with lowest value (rank 0)

record, err := client.Operate(nil, key,

    as.MapGetByRankOp("scores", 0, as.MapReturnType.KEY_VALUE),

)

// Get item with highest value (rank -1)

record, err := client.Operate(nil, key,

    as.MapGetByRankOp("scores", -1, as.MapReturnType.KEY_VALUE),

)

results := record.Bins["scores"].([]as.MapPair)

topPlayer := results[0]

fmt.Printf("Top player: %v with score %v\n", topPlayer.Key, topPlayer.Value)
```

**Understanding ranks:**

-   Rank 0: Smallest/lowest value
-   Rank 1: Second smallest value
-   Rank -1: Largest/highest value (most common for leaderboards)
-   Rank -2: Second largest value

#### `MapGetByValueOp`: get keys by value

Finds all keys that have a specific value.

```go
// Find all users with score 100

record, err := client.Operate(nil, key,

    as.MapGetByValueOp("scores", 100, as.MapReturnType.KEY),

)

userIds := record.Bins["scores"].([]any) // All users with score 100
```

#### `MapSizeOp`: get map size

Returns the number of items in the map.

```go
// Get map size

record, err := client.Operate(nil, key,

    as.MapSizeOp("profile"),

)

size := record.Bins["profile"].(int)

fmt.Printf("Profile has %d fields\n", size)
```