Get

Get allows you to retrieve Items by one of their full key paths. If no Item exists at that key path, nothing is returned. Like Put, Get supports batch requests of up to 50 key paths at a time, returning all the items that exist.

In order to Get an Item you must know one of its key paths, which were defined as part of the Item Type’s schema. Each SDK contains some helpers to build key paths.

Clients automatically parse the returned Items into typed objects, though depending on the language you may have different methods for checking which type an Item is.

For this example we’ll use the schema defined in Example: Movies Schema, which declares Movie as an Item Type with the key path /movies-:id.


15 collapsed lines
1
package main
2

3
import (
4
  "context"
5
  "fmt"
6
  "os"
7
  "slices"
8
  "strconv"
9
  "time"
10

11
  "github.com/StatelyCloud/go-sdk/stately"
12
  // This is the code you generated from schema
13
  "github.com/StatelyCloud/stately/go-sdk-sample/schema"
14
)
15

16
func sampleGet(
17
  ctx context.Context,
18
  client stately.Client,
19
  movieID []byte,
20
) (*schema.Movie, error) {
21
  item, err := client.Get(
22
    ctx,
23
    // Construct the key path for the movie
24
    "/movie-"+stately.ToKeyID(movieID),
25
  )
26
  if err != nil {
27
    return nil, err
28
  }
29
  if item == nil { // Item not found
30
    return nil, nil
31
  }
32
  if movie, ok := item.(*schema.Movie); ok {
33
    return movie, nil
34
  }
35
  return nil, fmt.Errorf("item is not a Movie")
36
}
37

38
  item, err := client.WithAllowStale(true).Get(
39
    ctx,
40
    "/movie-"+stately.ToKeyID(movieID),
41
  )


6 collapsed lines
1
require 'bundler/setup'
2
require 'statelydb'
3
require_relative 'schema/stately.item_types'
4
require 'byebug'
5

6

7
def sample_get(client, movie_id)
8
  # Construct the key path for the movie
9
  key_path = StatelyDB::KeyPath.with('movie', movie_id)
10
  item = client.get(key_path)
11
  return item
12
end
13
  item = client.with_allow_stale(true).get(key_path)


9 collapsed lines
1
from __future__ import annotations
2

3
from typing import TYPE_CHECKING
4

5
from statelydb import ListToken, SyncChangedItem, SyncDeletedItem, SyncReset, key_path
6

7
from .schema import Actor, Change, Character, Client, Movie
8

9

10
async def sample_get(client: Client, movie_id: UUID) -> Movie | None:
11
    # Construct the key path for the movie
12
    kp = key_path("movie-{id}", id=movie_id)
13
    # Tell get that we expect a Movie
14
    return await client.get(Movie, kp)


3 collapsed lines
1
import { createClient, DatabaseClient, Movie } from "./schema/index.js";
2
import { keyPath, ListToken } from "@stately-cloud/client";
3

4
async function sampleGet(
5
  client: DatabaseClient,
6
  movieId: Uint8Array,
7
): Promise<Movie | undefined> {
8
  // Construct the key path for the movie
9
  const kp = keyPath`/movie-${movieId}`;
10
  // Tell get that we expect a Movie
11
  const item = await client.get("Movie", kp);
12
  return item;
13
}

1
# There are no key path helpers for shell, so you need to
2
# manually base64-encode the UUID's bytes
3
stately item get \
4
  --store-id <store-id-goes-here> \
5
  --item-key '/movie-2hC3sMFFSlelJlFf9hRD9g'