Momento Cache API リファレンス

コントロールAPI

これらのAPIメソッドは、cacheを管理・制御するために使用されます。

Create cache

指定された名前のcacheを作成します。

属性:

名前	型	説明
cacheName	String	作成するcacheの名前。

const result = await cacheClient.createCache(cacheName);
switch (result.type) {
  case CreateCacheResponse.AlreadyExists:
    console.log(`Cache '${cacheName}' already exists`);
    break;
  case CreateCacheResponse.Success:
    console.log(`Cache '${cacheName}' created`);
    break;
  case CreateCacheResponse.Error:
    throw new Error(
      `An error occurred while attempting to create cache '${cacheName}': ${result.errorCode()}: ${result.toString()}`
    );
}

create_cache_response = await cache_client.create_cache("test-cache")
match create_cache_response:
    case CreateCache.Success():
        print("Cache 'test-cache' created")
    case CreateCache.CacheAlreadyExists():
        print("Cache 'test-cache' already exists.")
    case CreateCache.Error() as error:
        print(f"An error occurred while attempting to create cache 'test-cache': {error.message}")

final CacheCreateResponse response = cacheClient.createCache("test-cache").join();
if (response instanceof CacheCreateResponse.Success) {
  System.out.println("Cache 'test-cache' created");
} else if (response instanceof CacheCreateResponse.Error error) {
  if (error.getErrorCode() == MomentoErrorCode.ALREADY_EXISTS_ERROR) {
    System.out.println("Cache 'test-cache' already exists");
  } else {
    throw new RuntimeException(
        "An error occurred while attempting to create cache 'test-cache': "
            + error.getErrorCode(),
        error);
  }
}

when (val response = cacheClient.createCache("test-cache")) {
    is CacheCreateResponse.Success -> println("Cache 'test-cache' created")
    is CacheCreateResponse.AlreadyExists -> println("Cache 'test-cache' already exists")
    is CacheCreateResponse.Error -> throw RuntimeException(
        "An error occurred while attempting to create cache 'test-cache': ${response.errorCode}", response
    )
}

_, err := client.CreateCache(ctx, &momento.CreateCacheRequest{
	CacheName: cacheName,
})
if err != nil {
	panic(err)
}

var result = await cacheClient.CreateCacheAsync("test-cache");
if (result is CreateCacheResponse.Success)
{
    Console.WriteLine("Cache 'test-cache' created");
}
else if (result is CreateCacheResponse.CacheAlreadyExists)
{
    Console.WriteLine("Cache 'test-cache' already exists");
}
else if (result is CreateCacheResponse.Error error)
{
    throw new Exception($"An error occurred while attempting to create cache 'test-cache': {error.ErrorCode}: {error}");
}

$create_cache_response = $cache_client->createCache($cache_name);
if ($create_cache_response->asSuccess()) {
    print("Cache $cache_name created\n");
} elseif ($create_cache_response->asAlreadyExists()) {
    print("Cache $cache_name already exists\n");
} elseif ($err = $create_cache_response->asError()) {
    print("An error occurred while attempting to create $cache_name: {$err->errorCode()} - {$err->message()}\n");
}

  match cache_client.create_cache(cache_name).await? {
      CreateCacheResponse::Created => println!("Cache {} created", cache_name),
      CreateCacheResponse::AlreadyExists => println!("Cache {} already exists", cache_name),
  }

case Momento.CacheClient.create_cache(client, "test-cache") do
  {:ok, _} ->
    IO.puts("Cache 'test-cache' created")

  :already_exists ->
    :ok

  {:error, error} ->
    IO.puts(
      "An error occurred while attempting to create cache 'test-cache': #{error.error_code}"
    )

    raise error
end

let result = await cacheClient.createCache(cacheName: cacheName)
switch result {
case .alreadyExists(_):
    print("Cache already exists!")
case .success(_):
    print("Successfully created the cache!")
case .error(let err):
    print("Unable to create the cache: \(err)")
    exit(1)
}

final result = await cacheClient.createCache("test-cache");
switch (result) {
  case CreateCacheAlreadyExists():
    print("Cache already exists");
  case CreateCacheError():
    print("Error creating cache: $result");
  case CreateCacheSuccess():
    print("Successfully created the cache");
}

Delete cache

cacheを削除します。

属性:

名前	型	説明
cacheName	String	削除するcacheの名前。

const result = await cacheClient.deleteCache(cacheName);
switch (result.type) {
  case DeleteCacheResponse.Success:
    console.log(`Cache '${cacheName}' deleted`);
    break;
  case DeleteCacheResponse.Error:
    throw new Error(
      `An error occurred while attempting to delete cache '${cacheName}': ${result.errorCode()}: ${result.toString()}`
    );
}

delete_cache_response = await cache_client.delete_cache("test-cache")
match delete_cache_response:
    case DeleteCache.Success():
        print("Cache 'test-cache' deleted")
    case DeleteCache.Error() as error:
        raise Exception(f"An error occurred while attempting to delete 'test-cache': {error.message}")

final CacheDeleteResponse response = cacheClient.deleteCache("test-cache").join();
if (response instanceof CacheDeleteResponse.Success) {
  System.out.println("Cache 'test-cache' deleted");
} else if (response instanceof CacheDeleteResponse.Error error) {
  throw new RuntimeException(
      "An error occurred while attempting to delete cache 'test-cache': "
          + error.getErrorCode(),
      error);
}

when (val response = cacheClient.deleteCache("test-cache")) {
    is CacheDeleteResponse.Success -> println("Cache 'test-cache' deleted")
    is CacheDeleteResponse.Error -> throw RuntimeException(
        "An error occurred while attempting to delete cache 'test-cache': ${response.errorCode}", response
    )
}

_, err := client.DeleteCache(ctx, &momento.DeleteCacheRequest{
	CacheName: cacheName,
})
if err != nil {
	panic(err)
}

var result = await cacheClient.DeleteCacheAsync("test-cache");
if (result is DeleteCacheResponse.Success)
{
    Console.WriteLine("Cache 'test-cache' deleted");
}
else if (result is DeleteCacheResponse.Error error)
{
    throw new Exception($"An error occurred while attempting to delete cache 'test-cache': {error.ErrorCode}: {error}");
}

$delete_cache_response = $cache_client->deleteCache($cache_name);
if ($err = $delete_cache_response->asError()) {
    print("An error occurred while attempting to delete $cache_name: {$err->errorCode()} - {$err->message()}\n");
} else {
    print("Cache $cache_name deleted\n");
}

  cache_client.delete_cache(cache_name).await?;
  println!("Cache {} deleted", cache_name);

case Momento.CacheClient.delete_cache(client, "test-cache") do
  {:ok, _} ->
    IO.puts("Cache 'test-cache' deleted")

  {:error, error} ->
    IO.puts(
      "An error occurred while attempting to delete cache 'test-cache': #{error.error_code}"
    )

    raise error
end

let result = await cacheClient.deleteCache(cacheName: cacheName)
switch result {
case .success(let success):
    print("Successfully deleted the cache")
case .error(let err):
    print("Unable to delete cache: \(err)")
    exit(1)
}

final result = await cacheClient.deleteCache("test-cache");
switch (result) {
  case DeleteCacheError():
    print("Error deleting cache: $result");
    exit(1);
  case DeleteCacheSuccess():
    print("Successfully deleted cache");
}

List caches

すべてのcacheのリストを返します。

const result = await cacheClient.listCaches();
switch (result.type) {
  case ListCachesResponse.Success:
    console.log(
      `Caches:\n${result
        .getCaches()
        .map(c => c.getName())
        .join('\n')}\n\n`
    );
    break;
  case ListCachesResponse.Error:
    throw new Error(`An error occurred while attempting to list caches: ${result.errorCode()}: ${result.toString()}`);
}

print("Listing caches:")
list_caches_response = await cache_client.list_caches()
match list_caches_response:
    case ListCaches.Success() as success:
        for cache_info in success.caches:
            print(f"- {cache_info.name!r}")
    case ListCaches.Error() as error:
        raise Exception(f"An error occurred while attempting to list caches: {error.message}")

final CacheListResponse response = cacheClient.listCaches().join();
if (response instanceof CacheListResponse.Success success) {
  final String caches =
      success.getCaches().stream().map(CacheInfo::name).collect(Collectors.joining("\n"));
  System.out.println("Caches:\n" + caches);
} else if (response instanceof CacheListResponse.Error error) {
  throw new RuntimeException(
      "An error occurred while attempting to list caches: " + error.getErrorCode(), error);
}

when (val response: CacheListResponse = cacheClient.listCaches()) {
    is CacheListResponse.Success -> {
        val caches: String = response.caches.joinToString("\n") { cacheInfo -> cacheInfo.name }
        println("Caches:\n$caches")
    }

    is CacheListResponse.Error -> throw RuntimeException(
        "An error occurred while attempting to list caches: ${response.errorCode}", response
    )
}

resp, err := client.ListCaches(ctx, &momento.ListCachesRequest{})
if err != nil {
	panic(err)
}

switch r := resp.(type) {
case *responses.ListCachesSuccess:
	log.Printf("Found caches %+v\n", r.Caches())
}

var result = await cacheClient.ListCachesAsync();
if (result is ListCachesResponse.Success success)
{
    Console.WriteLine($"Caches:\n{string.Join("\n", success.Caches.Select(c => c.Name))}\n\n");
}
else if (result is ListCachesResponse.Error error)
{
    throw new Exception($"An error occurred while attempting to list caches: {error.ErrorCode}: {error}");
}

$list_caches_response = $cache_client->listCaches();
if ($success = $list_caches_response->asSuccess()) {
    print("Found caches:\n");
    foreach ($success->caches() as $cache) {
        $cache_name = $cache->name();
        print("- $cache_name\n");
    }
} elseif ($err = $list_caches_response->asError()) {
    print("An error occurred while attempting to list caches: {$err->errorCode()} - {$err->message()}\n");
}

  let response = cache_client.list_caches().await?;
  println!("Caches: {:#?}", response.caches);

case Momento.CacheClient.list_caches(client) do
  {:ok, result} ->
    IO.puts("Caches:")
    IO.inspect(result.caches)

  {:error, error} ->
    IO.puts("An error occurred while attempting to list caches: #{error.error_code}")
    raise error
end

let result = await cacheClient.listCaches()
switch result {
case .success(let success):
    print("Successfully fetched list of caches: \(success.caches.map { $0.name })")
case .error(let err):
    print("Unable to fetch list of caches: \(err)")
    exit(1)
}

final result = await cacheClient.listCaches();
switch (result) {
  case ListCachesError():
    print("Error listing caches: $result");
  case ListCachesSuccess():
    print("Successfully listed caches: ${result.cacheNames}");
}

Flush cache

cacheの全データをフラッシュします。

属性:

名前	型	説明
cacheName	String	フラッシュするcacheの名前。

JavaScript
Java
C#
Rust

const result = await cacheClient.flushCache(cacheName);
switch (result.type) {
  case FlushCacheResponse.Success:
    console.log(`Cache '${cacheName}' flushed`);
    break;
  case FlushCacheResponse.Error:
    throw new Error(
      `An error occurred while attempting to flush cache '${cacheName}': ${result.errorCode()}: ${result.toString()}`
    );
}

final CacheFlushResponse response = cacheClient.flushCache("test-cache").join();
if (response instanceof CacheFlushResponse.Success) {
  System.out.println("Cache 'test-cache' flushed");
} else if (response instanceof CacheFlushResponse.Error error) {
  throw new RuntimeException(
      "An error occurred while attempting to flush cache 'test-cache': " + error.getErrorCode(),
      error);
}

var result = await cacheClient.FlushCacheAsync("test-cache");
if (result is FlushCacheResponse.Success)
{
    Console.WriteLine("Cache 'test-cache' flushed");
}
else if (result is FlushCacheResponse.Error error)
{
    throw new Exception($"An error occurred while attempting to flush cache 'test-cache': {error.ErrorCode}: {error}");
}

  cache_client.flush_cache(cache_name.to_string()).await?;
  println!("Cache {} flushed", cache_name);

:::ヒント

Delete Cache、Create Cacheの順に使用することでこのプロセスを模倣できますが、FlushCache APIはcacheの設定を保持したまま、データのみを削除します。

:::

データAPI

これらのAPIメソッドは、cache内のデータを直接操作するために使用されます。

Set

指定された生存時間(TTL)秒の値をcacheに設定します。このkeyの値がすでに存在する場合は、前の値のデータタイプが何であれ、新しい値で置き換えられます。

名前	型	説明
cacheName	String	cacheの名前。
key	[]Byte	値を追加するkey。
value	[]Byte	格納される値。
ttlSeconds	int	cache内のアイテムのTTL。

const result = await cacheClient.set(cacheName, 'test-key', 'test-value');
switch (result.type) {
  case CacheSetResponse.Success:
    console.log("Key 'test-key' stored successfully");
    break;
  case CacheSetResponse.Error:
    throw new Error(
      `An error occurred while attempting to store key 'test-key' in cache '${cacheName}': ${result.errorCode()}: ${result.toString()}`
    );
}

set_response = await cache_client.set("test-cache", "test-key", "test-value")
match set_response:
    case CacheSet.Success():
        print("Key 'test-key' stored successfully")
    case CacheSet.Error() as error:
        raise Exception(
            f"An error occurred while attempting to store key 'test-key' in cache 'test-cache': {error.message}"
        )

final SetResponse response = cacheClient.set("test-cache", "test-key", "test-value").join();
if (response instanceof SetResponse.Success) {
  System.out.println("Key 'test-key' stored successfully");
} else if (response instanceof SetResponse.Error error) {
  throw new RuntimeException(
      "An error occurred while attempting to store key 'test-key' in cache 'test-cache': "
          + error.getErrorCode(),
      error);
}

when (val response = cacheClient.set("test-cache", "test-key", "test-value")) {
    is SetResponse.Success -> println("Key 'test-key' stored successfully")
    is SetResponse.Error -> throw RuntimeException(
        "An error occurred while attempting to store key 'test-key' in cache 'test-cache': ${response.errorCode}",
        response
    )
}

key := uuid.NewString()
value := uuid.NewString()
log.Printf("Setting key: %s, value: %s\n", key, value)
_, err := client.Set(ctx, &momento.SetRequest{
	CacheName: cacheName,
	Key:       momento.String(key),
	Value:     momento.String(value),
	Ttl:       time.Duration(9999),
})
if err != nil {
	var momentoErr momento.MomentoError
	if errors.As(err, &momentoErr) {
		if momentoErr.Code() != momento.TimeoutError {
			// this would represent a client-side timeout, and you could fall back to your original data source
		} else {
			panic(err)
		}
	}
}

var result = await cacheClient.SetAsync("test-cache", "test-key", "test-value");
if (result is CacheSetResponse.Success)
{
    Console.WriteLine("Key 'test-key' stored successfully");
}
else if (result is CacheSetResponse.Error error)
{
    throw new Exception($"An error occurred while attempting to store key 'test-key' in cache 'test-cache': {error.ErrorCode}: {error}");
}

$set_response = $cache_client->set($cache_name, "test-key", "test-value");
if ($set_response->asSuccess()) {
    print("Key $cache_name stored successfully\n");
} elseif ($err = $set_response->asError()) {
    print("An error occurred while attempting to store $cache_name: {$err->errorCode()} - {$err->message()}\n");
}

  cache_client.set(cache_name, "key", "value").await?;
  println!("Value stored");

case Momento.CacheClient.set(client, "test-cache", "test-key", "test-value") do
  {:ok, _} ->
    IO.puts("Key 'test-key' stored successfully")

  {:error, error} ->
    IO.puts(
      "An error occurred while attempting to store key 'test-key' in cache 'test-cache': #{error.error_code}"
    )

    raise error
end

let result = await cacheClient.set(
    cacheName: cacheName,
    key: "key",
    value: "value"
)
switch result {
case .success(_):
    print("Successfully set item in the cache")
case .error(let err):
    print("Unable to set item in the cache: \(err)")
    exit(1)
}

final result = await cacheClient.set("test-cache", "test-key", "test-value");
switch (result) {
  case SetError():
    print("Error setting key: $result");
    exit(1);
  case SetSuccess():
    print("Successfully set item in the cache");
}

SetBatch

複数のキーと値のペアを、指定されたTTL（Time To Live）秒数でキャッシュに設定します。キーの値がすでに存在する場合は、前の値のデータタイプが何であれ、新しい値に置き換えられます。

Name	Type	Description
cacheName	String	キャッシュの名前
items	{ String/[]Byte : String/[]Byte }	格納されるべきキーと値のマッピング
ttlSeconds	int	キャッシュにあるアイテムのために生きる時間

JavaScript
Go

const values = new Map<string, string>([
  ['abc', '123'],
  ['xyz', '321'],
  ['123', 'xyz'],
  ['321', 'abc'],
]);
const result = await cacheClient.setBatch(cacheName, values);
switch (result.type) {
  case CacheSetBatchResponse.Success:
    console.log('Keys and values stored successfully');
    break;
  case CacheSetBatchResponse.Error:
    throw new Error(
      `An error occurred while attempting to batch set in cache '${cacheName}': ${result.errorCode()}: ${result.toString()}`
    );
}

resp, err := client.SetBatch(ctx, &momento.SetBatchRequest{
	CacheName: cacheName,
	Items: []momento.BatchSetItem{
		{
			Key:   momento.String("key1"),
			Value: momento.String("value1"),
		},
		{
			Key:   momento.String("key2"),
			Value: momento.String("value2"),
		},
	},
})
if err != nil {
	panic(err)
}
switch resp.(type) {
case *responses.SetBatchSuccess:
	log.Printf("Successfully set keys in cache\n")
}

メソッド・レスポンス・オブジェクト

Success

results(): CacheSet.Response[]

Error

Get

指定されたkeyに対して格納されているcache値を取得します。

名前	型	説明
cacheName	String	cacheの名前。
key	[]Byte	値を取得するために指定するkeyです。

const getResponse = await cacheClient.get(cacheName, 'test-key');
// simplified style; assume the value was found
console.log(`cache hit: ${getResponse.value()!}`);

// pattern-matching style; safer for production code
switch (getResponse.type) {
  case CacheGetResponse.Hit:
    console.log(`Retrieved value for key 'test-key': ${getResponse.valueString()}`);
    break;
  case CacheGetResponse.Miss:
    console.log(`Key 'test-key' was not found in cache '${cacheName}'`);
    break;
  case CacheGetResponse.Error:
    throw new Error(
      `An error occurred while attempting to get key 'test-key' from cache '${cacheName}': ${getResponse.errorCode()}: ${getResponse.toString()}`
    );
}

get_response = await cache_client.get("test-cache", "test-key")
match get_response:
    case CacheGet.Hit() as hit:
        print(f"Retrieved value for key 'test-key': {hit.value_string}")
    case CacheGet.Miss():
        print("Key 'test-key' was not found in cache 'test-cache'")
    case CacheGet.Error() as error:
        raise Exception(
            f"An error occurred while attempting to get key 'test-key' from cache 'test-cache': {error.message}"
        )

final GetResponse response = cacheClient.get("test-cache", "test-key").join();
if (response instanceof GetResponse.Hit hit) {
  System.out.println("Retrieved value for key 'test-key': " + hit.valueString());
} else if (response instanceof GetResponse.Miss) {
  System.out.println("Key 'test-key' was not found in cache 'test-cache'");
} else if (response instanceof GetResponse.Error error) {
  throw new RuntimeException(
      "An error occurred while attempting to get key 'test-key' from cache 'test-cache': "
          + error.getErrorCode(),
      error);
}

when (val response = cacheClient.get("test-cache", "test-key")) {
    is GetResponse.Hit -> println("Retrieved value for key 'test-key': ${response.value}")
    is GetResponse.Miss -> println("Key 'test-key' was not found in cache 'test-cache'")
    is GetResponse.Error -> throw RuntimeException(
        "An error occurred while attempting to get key 'test-key' from cache 'test-cache': ${response.errorCode}",
        response
    )
}

key := uuid.NewString()
resp, err := client.Get(ctx, &momento.GetRequest{
	CacheName: cacheName,
	Key:       momento.String(key),
})
if err != nil {
	panic(err)
}

switch r := resp.(type) {
case *responses.GetHit:
	log.Printf("Lookup resulted in cache HIT. value=%s\n", r.ValueString())
case *responses.GetMiss:
	log.Printf("Look up did not find a value key=%s\n", key)
}

var result = await cacheClient.GetAsync("test-cache", "test-key");
if (result is CacheGetResponse.Hit hit)
{
    Console.WriteLine($"Retrieved value for key 'test-key': {hit.ValueString}");
}
else if (result is CacheGetResponse.Miss)
{
    Console.WriteLine("Key 'test-key' was not found in cache 'test-cache'");
}
else if (result is CacheGetResponse.Error error)
{
    throw new Exception($"An error occurred while attempting to get key 'test-key' from cache 'test-cache': {error.ErrorCode}: {error}");
}

$get_response = $cache_client->get($cache_name, "test-key");
if ($hit = $get_response->asHit()) {
    print("Retrieved value for key 'test-key': {$hit->valueString()}\n");
} elseif ($get_response->asMiss()) {
    print("Key 'test-key' was not found in cache $cache_name\n");
} elseif ($err = $get_response->asError()) {
    print("An error occurred while attempting to get key 'test-key' from cache $cache_name: {$err->errorCode()} - {$err->message()}\n");
}

  let response = cache_client.get(cache_name, "key").await?;
  let _item: String = response.try_into().expect("I stored a string!");

case Momento.CacheClient.get(client, "test-cache", "test-key") do
  {:ok, hit} ->
    IO.puts("Retrieved value for key 'test-key': #{hit.value}")

  :miss ->
    IO.puts("Key 'test-key' was not found in cache 'test-cache'")

  {:error, error} ->
    IO.puts(
      "An error occurred while attempting to get key 'test-key' from cache 'test-cache': #{error.error_code}"
    )

    raise error
end

let result = await cacheClient.get(
    cacheName: cacheName,
    key: "key"
)
switch result {
case .hit(let hit):
    print("Cache hit: \(hit.valueString)")
case .miss(_):
    print("Cache miss")
case .error(let err):
    print("Unable to get item in the cache: \(err)")
    exit(1)
}

final result = await cacheClient.get("test-cache", "test-key");
switch (result) {
  case GetMiss():
    print("Key was not found in cache.");
  case GetError():
    print("Error getting key: $result");
  case GetHit():
    print("Successfully got item from cache: ${result.value}");
}

GetBatch

指定したキーに対応するキャッシュ値を取得します。

Name	Type	Description
cacheName	String	キャッシュの名前
keys	String[] / Bytes[]	値を取得するキーのリスト

JavaScript
Go

const keys = ['abc', 'xyz', '123', '321'];
const getBatchResponse = await cacheClient.getBatch(cacheName, keys);

// simplified style; assume the value was found
const values = getBatchResponse.values()!;
for (const key of keys) {
  console.log(`Retrieved value for key '${key}': ${values[key]}`);
}

// pattern-matching style; safer for production code
switch (getBatchResponse.type) {
  case CacheGetBatchResponse.Success: {
    const values = getBatchResponse.values();
    for (const key of keys) {
      console.log(`Retrieved value for key '${key}': ${values[key]}`);
    }
    break;
  }
  case CacheGetBatchResponse.Error:
    throw new Error(
      `An error occurred while attempting to batch get in cache '${cacheName}': ${getBatchResponse.errorCode()}: ${getBatchResponse.toString()}`
    );
}

resp, err := client.GetBatch(ctx, &momento.GetBatchRequest{
	CacheName: cacheName,
	Keys:      []momento.Value{momento.String("key1"), momento.String("key2")},
})
if err != nil {
	panic(err)
}
switch r := resp.(type) {
case *responses.GetBatchSuccess:
	log.Printf("Found values %+v\n", r.ValueMap())
}

メソッド・レスポンス・オブジェクト

Success

values(): Record<string, string>
results(): CacheGet.Response[]

Error

Delete

与えられたkeyに対して格納されているcache値を削除します。

名前	型	説明
cacheName	String	cacheの名前。
key	[]Byte	値を削除するために指定するkey。

const result = await cacheClient.delete(cacheName, 'test-key');
switch (result.type) {
  case CacheDeleteResponse.Success:
    console.log("Key 'test-key' deleted successfully");
    break;
  case CacheDeleteResponse.Error:
    throw new Error(
      `An error occurred while attempting to delete key 'test-key' from cache '${cacheName}': ${result.errorCode()}: ${result.toString()}`
    );
}

delete_response = await cache_client.delete("test-cache", "test-key")
match delete_response:
    case CacheDelete.Success():
        print("Key 'test-key' deleted successfully")
    case CacheDelete.Error() as error:
        raise Exception(
            f"An error occurred while attempting to delete key 'test-key' from cache 'test-cache': {error.message}"
        )

final DeleteResponse response = cacheClient.delete("test-cache", "test-key").join();
if (response instanceof DeleteResponse.Success) {
  System.out.println("Key 'test-key' deleted successfully");
} else if (response instanceof DeleteResponse.Error error) {
  throw new RuntimeException(
      "An error occurred while attempting to delete key 'test-key' from cache 'test-cache': "
          + error.getErrorCode(),
      error);
}

when (val response = cacheClient.delete("test-cache", "test-key")) {
    is DeleteResponse.Success -> println("Key 'test-key' deleted successfully")
    is DeleteResponse.Error -> throw RuntimeException(
        "An error occurred while attempting to delete key 'test-key' from cache 'test-cache': ${response.errorCode}",
        response
    )
}

key := uuid.NewString()
_, err := client.Delete(ctx, &momento.DeleteRequest{
	CacheName: cacheName,
	Key:       momento.String(key),
})
if err != nil {
	panic(err)
}

var result = await cacheClient.DeleteAsync("test-cache", "test-key");
if (result is CacheDeleteResponse.Success)
{
    Console.WriteLine("Key 'test-key' deleted successfully");
}
else if (result is CacheDeleteResponse.Error error)
{
    throw new Exception($"An error occurred while attempting to delete key 'test-key' from cache 'test-cache': {error.ErrorCode}: {error}");
}

$delete_response = $cache_client->delete($cache_name, "test-key");
if ($delete_response->asSuccess()) {
    print("Key 'test-key' deleted successfully\n");
} elseif ($err = $delete_response->asError()) {
    print("An error occurred while attempting to delete key 'test-key' from cache $cache_name: {$err->errorCode()} - {$err->message()}\n");
}

  cache_client.delete(cache_name, "key").await?;
  println!("Value deleted");

case Momento.CacheClient.delete(client, "test-cache", "test-key") do
  {:ok, _} ->
    IO.puts("Key 'test-key' deleted successfully")

  {:error, error} ->
    IO.puts(
      "An error occurred while attempting to delete key 'test-key' from cache 'test-cache': #{error.error_code}"
    )

    raise error
end

let result = await cacheClient.delete(
    cacheName: cacheName,
    key: "key"
)
switch result {
case .success(_):
    print("Successfully deleted item in the cache")
case .error(let err):
    print("Unable to delete item in the cache: \(err)")
    exit(1)
}

final result = await cacheClient.delete("test-cache", "test-key");
switch (result) {
  case DeleteError():
    print("Error deleting key: $result");
    exit(1);
  case DeleteSuccess():
    print("Successfully deleted key from cache");
}

Increment

既存の値がベース10(10進法)の整数を表すUTF-8文字列である場合に限り、フィールドの値を追加します。もしフィールドが存在しない場合、このメソッドはフィールドの値をインクリメントして設定します。

名前	型	説明
cacheName	String	cacheの名前。
field	String	値のインクリメントする場合の対象となるkey。
amount	Integer	値に加算する量です。正の値、負の値、またはゼロを指定します。デフォルトは1。

:::注記

インクリメントされた値は、-9223372036854775808から9223372036854775807の間、つまり64ビット符号付き整数配列でなければなりません。そうでない場合は、エラーが返されます。

:::

JavaScript
Java
Go
Rust

await cacheClient.set(cacheName, 'test-key', '10');
const result = await cacheClient.increment(cacheName, 'test-key', 1);
switch (result.type) {
  case CacheIncrementResponse.Success:
    console.log(`Key 'test-key' incremented successfully. New value in key test-key: ${result.valueNumber()}`);
    break;
  case CacheIncrementResponse.Error:
    throw new Error(
      `An error occurred while attempting to increment the value of key 'test-key' from cache '${cacheName}': ${result.errorCode()}: ${result.toString()}`
    );
}

cacheClient.set("test-cache", "test-key", "10").join();
final IncrementResponse response = cacheClient.increment("test-cache", "test-key", 1).join();
if (response instanceof IncrementResponse.Success success) {
  System.out.println(
      "Key 'test-key' incremented successfully. New value in key test-key: "
          + success.valueNumber());
} else if (response instanceof IncrementResponse.Error error) {
  throw new RuntimeException(
      "An error occurred while attempting to increment the value of key 'test-key' from cache 'test-cache': "
          + error.getErrorCode(),
      error);
}

resp, err := client.Increment(ctx, &momento.IncrementRequest{
	CacheName: cacheName,
	Field:     momento.String("key"),
	Amount:    1,
})
if err != nil {
	panic(err)
}
switch r := resp.(type) {
case *responses.IncrementSuccess:
	log.Printf("Incremented value is %d\n", r.Value())
}

  let response = cache_client.increment(cache_name, "key", 1).await?;
  println!("Value incremented to {}", response.value);

Ping

サーバにpingを送信します。このAPIは、クライアントがサーバに正常に接続できることを確認するための接続性のチェックに使用できます。

メソッドのレスポンスオブジェクト

Success
Error

具体的な情報については、レスポンスオブジェクトを参照してください。

ItemGetType

与えられたkeyに対して、対応するアイテムが存在する場合、その型(SCALAR、DICTIONARY、LISTなど)を返します。

名前	型	説明
cacheName	String	cacheの名前。
key	String \| Byte	itemの型が返却されるべきkey。

メソッドのレスポンスオブジェクト

Cache hit

型(): enum: SCALAR, DICTIONARY, SET, LIST, SORTED_SET

Cache miss
Cache error

具体的な情報については、レスポンスオブジェクトを参照してください。

JavaScript
Go
Rust

const result = await cacheClient.itemGetType(cacheName, 'test-key');
switch (result.type) {
  case CacheItemGetTypeResponse.Hit:
    console.log(`Item type retrieved successfully: ${ItemType[result.itemType()]}`);
    break;
  case CacheItemGetTypeResponse.Miss:
    console.log("Key 'test-key' was not found in cache '${cacheName}'");
    break;
  case CacheItemGetTypeResponse.Error:
    throw new Error(
      `An error occurred while attempting to get the type of key 'test-key' from cache '${cacheName}': ${result.errorCode()}: ${result.toString()}`
    );
}

resp, err := client.ItemGetType(ctx, &momento.ItemGetTypeRequest{
	CacheName: cacheName,
	Key:       momento.String("key"),
})
if err != nil {
	panic(err)
}
switch r := resp.(type) {
case *responses.ItemGetTypeHit:
	log.Printf("Type of item is %v\n", r.Type())
case *responses.ItemGetTypeMiss:
	log.Printf("Item does not exist in cache\n")
}

  let _item_type: ItemType = cache_client
      .item_get_type(cache_name, "key")
      .await?
      .try_into()
      .expect("Expected an item type!");

KeyExists

指定されたkeyがcacheに存在するかどうかをチェックします。

名前	型	説明
cacheName	String	cacheの名前。
key	String \| Byte	cacheに存在するかどうかをチェックするkey。

メソッドのレスポンスオブジェクト

Success

exists(): Bool

Error

具体的な情報については、レスポンスオブジェクトを参照してください。

JavaScript
Rust

const result = await cacheClient.keyExists(cacheName, 'test-key');
switch (result.type) {
  case CacheKeyExistsResponse.Success:
    console.log("Does 'test-key' exist in the cache?", result.exists());
    break;
  case CacheKeyExistsResponse.Error:
    throw new Error(
      `An error occurred while attempting to call keyExists on key 'test-key' in cache '${cacheName}': ${result.errorCode()}: ${result.toString()}`
    );
}

  let result = cache_client.key_exists(cache_name, "key").await?;
  if result.exists {
      println!("Key exists!");
  } else {
      println!("Key does not exist!");
  }

KeysExist

指定されたkey(複数)がcacheに存在するかどうかをチェックします。

名前	型	説明
cacheName	String	cacheの名前。
keys	String[] \| Byte[]	cacheに存在するかどうかをチェックするkey(複数)。

メソッドのレスポンスオブジェクト

Success

exists(): Bool[]

Error

具体的な情報については、レスポンスオブジェクトを参照してください。

JavaScript
Go
Rust

const result = await cacheClient.keysExist(cacheName, ['test-key1', 'test-key2']);
switch (result.type) {
  case CacheKeysExistResponse.Success:
    console.log("Do 'test-key1' and 'test-key2' exist in the cache?", result.exists());
    break;
  case CacheKeysExistResponse.Error:
    throw new Error(
      `An error occurred while attempting to call keysExist on keys 'test-key1' and 'test-key2' in cache '${cacheName}': ${result.errorCode()}: ${result.toString()}`
    );
}

keys := []momento.Value{momento.String("key1"), momento.String("key2")}
resp, err := client.KeysExist(ctx, &momento.KeysExistRequest{
	CacheName: cacheName,
	Keys:      keys,
})
if err != nil {
	panic(err)
}
switch r := resp.(type) {
case *responses.KeysExistSuccess:
	log.Printf("Does each key exist in cache?\n")
	for _, exists := range r.Exists() {
		log.Printf("key exists=%v\n", exists)
	}
}

  // Receive results as a HashMap
  let result_map: HashMap<String, bool> = cache_client
      .keys_exist(cache_name, vec!["key", "key1", "key2"])
      .await?
      .into();
  println!("Do these keys exist? {:#?}", result_map);

  // Or receive results as a Vec
  let result_list: Vec<bool> = cache_client
      .keys_exist(cache_name, vec!["key", "key1", "key2"])
      .await?
      .into();
  println!("Do these keys exist? {:#?}", result_list);

SetIfAbsent

警告

SetIfPresentのようなチェックアンドセット (CAS) API をSetやDeleteのようなスカラー API や非 CAS API と一緒に使用しないでください。そうすると、一貫性の動作が定義されません。代わりにSetIfAbsentをSetIfPresent` と一緒に使用してください。

キーがキャッシュにまだ存在しない場合は、指定されたキーを使用して、指定された値をキャッシュ項目に関連付けます。

Name	Type	Description
cacheName	String	キャッシュの名前
key	String \| Bytes	設定されるキー
value	String \| Bytes	保存する値
ttlSeconds	Duration	キャッシュ内のアイテムの生存時間

Method response object

Stored
NotStored
Error

詳しくはレスポンスオブジェクトを参照。

JavaScript
Go
Rust

const result = await cacheClient.setIfAbsent(cacheName, 'test-key', 'test-field');
switch (result.type) {
  case CacheSetIfAbsentResponse.Stored:
    console.log("Field 'test-field' set in key 'test-key'");
    break;
  case CacheSetIfAbsentResponse.NotStored:
    console.log(`Key 'test-key' already exists in cache ${cacheName}, so we did not overwrite it`);
    break;
  case CacheSetIfAbsentResponse.Error:
    throw new Error(
      `An error occurred while attempting to call setIfAbsent for the key 'test-key' in cache cacheName: ${result.errorCode()}: ${result.toString()}`
    );
}

resp, err := client.SetIfAbsent(ctx, &momento.SetIfAbsentRequest{
	CacheName: cacheName,
	Key:       momento.String("key"),
	Value:     momento.String("value"),
})
if err != nil {
	panic(err)
}
switch resp.(type) {
case *responses.SetIfAbsentStored:
	log.Printf("Successfully set key in cache\n")
}

  match cache_client
      .set_if_absent(cache_name, "key", "value")
      .await?
  {
      SetIfAbsentResponse::Stored => println!("Value stored"),
      SetIfAbsentResponse::NotStored => println!("Value not stored"),
  }

SetIfPresent

警告

指定されたキーが既にキャッシュに存在する場合は、指定された値を指定されたキーのキャッシュ項目に関連付けます。

Name	Type	Description
cacheName	String	キャッシュの名前
key	String \| Bytes	設定されるキー
value	String \| Bytes	保存する値
ttlSeconds	Duration	キャッシュ内のアイテムの生存時間

Method response object

Stored
NotStored
Error

詳しくはレスポンスオブジェクトを参照。

JavaScript
Go
Rust

const result = await cacheClient.setIfPresent(cacheName, 'test-key', 'test-field');
switch (result.type) {
  case CacheSetIfPresentResponse.Stored:
    console.log("Field 'test-field' set in key 'test-key'");
    break;
  case CacheSetIfPresentResponse.NotStored:
    console.log(`Key 'test-key' does not exist in cache ${cacheName}, so we did not set the field`);
    break;
  case CacheSetIfPresentResponse.Error:
    throw new Error(
      `An error occurred while attempting to call setIfPresent for the key 'test-key' in cache cacheName: ${result.errorCode()}: ${result.toString()}`
    );
}

resp, err := client.SetIfPresent(ctx, &momento.SetIfPresentRequest{
	CacheName: cacheName,
	Key:       momento.String("key"),
	Value:     momento.String("value"),
})
if err != nil {
	panic(err)
}
switch resp.(type) {
case *responses.SetIfPresentStored:
	log.Printf("Successfully set key in cache\n")
}

  match cache_client
      .set_if_present(cache_name, "key", "value")
      .await?
  {
      SetIfPresentResponse::Stored => println!("Value stored"),
      SetIfPresentResponse::NotStored => println!("Value not stored"),
  }

SetIfEqual

警告

SetIfEqualのようなチェックアンドセット (CAS) API をSetやDeleteのようなスカラー API や非 CAS API と一緒に使用しないでください。そうすると、一貫性のない動作になります。代わりにSetIfNotEqualをSetIfEqual` と一緒に使用してください。

指定されたキーが既にキャッシュ内に存在し、キャッシュ内の値が equal で指定された値と等しい場合に、指定された値を指定されたキーのキャッシュアイテムに関連付ける。

Name	Type	Description
cacheName	String	キャッシュの名前
key	String \| Bytes	設定されるキー
value	String \| Bytes	保存する値
equal	String \| Bytes	比較する値
ttlSeconds	Duration	キャッシュ内のアイテムの生存時間

Method response object

Stored
NotStored
Error

詳しくはレスポンスオブジェクトを参照。

JavaScript
Go
Rust

const result = await cacheClient.setIfEqual(cacheName, 'test-key', 'test-field', 'value-to-check');
switch (result.type) {
  case CacheSetIfEqualResponse.Stored:
    console.log("Field 'test-field' set in key 'test-key'");
    break;
  case CacheSetIfEqualResponse.NotStored:
    console.log("Value of key 'test-key' does not equal 'value-to-check', so we did not set the field");
    break;
  case CacheSetIfEqualResponse.Error:
    throw new Error(
      `An error occurred while attempting to call setIfEqual for the key 'test-key' in cache cacheName: ${result.errorCode()}: ${result.toString()}`
    );
}

resp, err := client.SetIfEqual(ctx, &momento.SetIfEqualRequest{
	CacheName: cacheName,
	Key:       momento.String("key"),
	Value:     momento.String("value"),
	Equal:     momento.String("current-value"),
})
if err != nil {
	panic(err)
}
switch resp.(type) {
case *responses.SetIfEqualStored:
	log.Printf("Successfully set key in cache\n")
}

  match cache_client
      .set_if_equal(cache_name, "key", "new-value", "cached-value")
      .await?
  {
      SetIfEqualResponse::Stored => println!("Value stored"),
      SetIfEqualResponse::NotStored => println!("Value not stored"),
  }

SetIfNotEqual

警告

指定したキーがキャッシュ内に存在しないか、キャッシュ内の値が notEqual で指定した値と等しくない場合に、指定した値を指定したキーのキャッシュアイテムに関連付ける。

Name	Type	Description
cacheName	String	キャッシュの名前
key	String \| Bytes	設定されるキー
value	String \| Bytes	保存する値
notEqual	String \| Bytes	比較する値
ttlSeconds	Duration	キャッシュ内のアイテムの生存時間

Method response object

Stored
NotStored
Error

詳しくはレスポンスオブジェクトを参照。

JavaScript
Go
Rust

const result = await cacheClient.setIfNotEqual(cacheName, 'test-key', 'test-field', 'value-to-check');
switch (result.type) {
  case CacheSetIfNotEqualResponse.Stored:
    console.log("Field 'test-field' set in key 'test-key'");
    break;
  case CacheSetIfNotEqualResponse.NotStored:
    console.log("Value of key 'test-key' equals 'value-to-check', so we did not set the field");
    break;
  case CacheSetIfNotEqualResponse.Error:
    throw new Error(
      `An error occurred while attempting to call setIfNotEqual for the key 'test-key' in cache cacheName: ${result.errorCode()}: ${result.toString()}`
    );
}

resp, err := client.SetIfNotEqual(ctx, &momento.SetIfNotEqualRequest{
	CacheName: cacheName,
	Key:       momento.String("key"),
	Value:     momento.String("value"),
	NotEqual:  momento.String("current-value"),
})
if err != nil {
	panic(err)
}
switch resp.(type) {
case *responses.SetIfNotEqualStored:
	log.Printf("Successfully set key in cache\n")
}

  match cache_client
      .set_if_not_equal(cache_name, "key", "new-value", "cached-value")
      .await?
  {
      SetIfNotEqualResponse::Stored => println!("Value stored"),
      SetIfNotEqualResponse::NotStored => println!("Value not stored"),
  }

SetIfPresentAndNotEqual

SetIfPresentAndNotEqualのようなチェックアンドセット (CAS) API をSetやDeleteのようなスカラー API や非 CAS API と一緒に使用しないでください。そのようなことをすると、一貫性の動作が未定義になります。代わりにSetIfAbsentOrEqual SetIfPresentAndNotEqual` を使用してください。 :::

指定されたキーが既にキャッシュ内に存在し、キャッシュ内の値が notEqual で指定された値と等しくない場合に、指定された値を指定されたキーのキャッシュアイテムに関連付ける。

Name	Type	Description
cacheName	String	キャッシュの名前
key	String \| Bytes	設定されるキー
value	String \| Bytes	保存する値
notEqual	String \| Bytes	比較する値
ttlSeconds	Duration	キャッシュ内のアイテムの生存時間

Method response object

Stored
NotStored
Error

詳しくはレスポンスオブジェクトを参照。

JavaScript
Go
Rust

const result = await cacheClient.setIfPresentAndNotEqual(cacheName, 'test-key', 'test-field', 'value-to-check');
switch (result.type) {
  case CacheSetIfPresentAndNotEqualResponse.Stored:
    console.log("Field 'test-field' set in key 'test-key'");
    break;
  case CacheSetIfPresentAndNotEqualResponse.NotStored:
    console.log(
      `Key 'test-key' does not exist in cache ${cacheName} or equals 'value-to-check', so we did not set the field`
    );
    break;
  case CacheSetIfPresentAndNotEqualResponse.Error:
    throw new Error(
      `An error occurred while attempting to call setIfPresentAndNotEqual for the key 'test-key' in cache cacheName: ${result.errorCode()}: ${result.toString()}`
    );
}

resp, err := client.SetIfPresentAndNotEqual(ctx, &momento.SetIfPresentAndNotEqualRequest{
	CacheName: cacheName,
	Key:       momento.String("key"),
	Value:     momento.String("value"),
	NotEqual:  momento.String("current-value"),
})
if err != nil {
	panic(err)
}
switch resp.(type) {
case *responses.SetIfPresentAndNotEqualStored:
	log.Printf("Successfully set key in cache\n")
}

  match cache_client
      .set_if_present_and_not_equal(cache_name, "key", "new-value", "cached-value")
      .await?
  {
      SetIfPresentAndNotEqualResponse::Stored => println!("Value stored"),
      SetIfPresentAndNotEqualResponse::NotStored => println!("Value not stored"),
  }

SetIfAbsentOrEqual

::警告 SetIfAbsentOrEqualのようなチェックアンドセット (CAS) API をSetやDeleteのようなスカラー API や非 CAS API と一緒に使用しないでください。そのようなことをすると、一貫性の動作が未定義になります。代わりにSetIfAbsentOrEqual と一緒SetIfPresentAndNotEqual` を使用してください。 :::

指定したキーがキャッシュ内に存在しないか、キャッシュ内の値が equal で指定した値と等しい場合に、指定した値を指定したキーのキャッシュアイテムに関連付ける。

Name	Type	Description
cacheName	String	キャッシュの名前
key	String \| Bytes	設定されるキー
value	String \| Bytes	保存する値
equal	String \| Bytes	比較する値
ttlSeconds	Duration	キャッシュ内のアイテムの生存時間

Method response object

Stored
NotStored
Error

詳しくはレスポンスオブジェクトを参照。

JavaScript
Go
Rust

const result = await cacheClient.setIfAbsentOrEqual(cacheName, 'test-key', 'test-field', 'value-to-check');
switch (result.type) {
  case CacheSetIfAbsentOrEqualResponse.Stored:
    console.log("Field 'test-field' set in key 'test-key'");
    break;
  case CacheSetIfAbsentOrEqualResponse.NotStored:
    console.log(
      `Key 'test-key' exists in cache ${cacheName} and is not equal to 'value-to-check', so we did not set the field`
    );
    break;
  case CacheSetIfAbsentOrEqualResponse.Error:
    throw new Error(
      `An error occurred while attempting to call setIfAbsentOrEqual for the key 'test-key' in cache cacheName: ${result.errorCode()}: ${result.toString()}`
    );
}

resp, err := client.SetIfAbsentOrEqual(ctx, &momento.SetIfAbsentOrEqualRequest{
	CacheName: cacheName,
	Key:       momento.String("key"),
	Value:     momento.String("value"),
	Equal:     momento.String("current-value"),
})
if err != nil {
	panic(err)
}
switch resp.(type) {
case *responses.SetIfAbsentOrEqualStored:
	log.Printf("Successfully set key in cache\n")
}

  match cache_client
      .set_if_absent_or_equal(cache_name, "key", "new-value", "cached-value")
      .await?
  {
      SetIfAbsentOrEqualResponse::Stored => println!("Value stored"),
      SetIfAbsentOrEqualResponse::NotStored => println!("Value not stored"),
  }

生存時間(TTL)API

これらのAPIは、すべての型のcacheに適用されます。

UpdateTtl

cacheアイテムのTTLを、指定された値(秒)で上書きします。

名前	型	説明
cacheName	String	cacheの名前。
key	String \| Bytes	値のTTLを上書きする対象のkey。
ttl	Duration	cacheで上書きしたいTTLを秒単位で指定します。

Go
Rust

resp, err := client.UpdateTtl(ctx, &momento.UpdateTtlRequest{
	CacheName: cacheName,
	Key:       momento.String("key"),
	Ttl:       time.Duration(9999),
})
if err != nil {
	panic(err)
}
switch resp.(type) {
case *responses.UpdateTtlSet:
	log.Printf("Successfully updated TTL for key\n")
case *responses.UpdateTtlMiss:
	log.Printf("Key does not exist in cache\n")
}

  match cache_client
      .update_ttl(cache_name, "key", Duration::from_secs(10))
      .await?
  {
      UpdateTtlResponse::Set => println!("TTL updated"),
      UpdateTtlResponse::Miss => println!("Cache miss, unable to find key to update TTL"),
  };

IncreaseTtl

TTLを増加させる場合のみ、keyのTTL秒数を指定された値に増やします。

例

TTLが5秒で、6秒を指定した場合、新しいTTLは6秒になります。
TTLが5秒で、3秒を指定した場合、TTLは増加しません。 | 名前 | 型 | 説明 | | --------- | ------ | ----------------------------------------------- | | cacheName | String | cacheの名前。 | | | key | String | Bytes | 値のTTLを増加させるkeyの指定。 | | ttl | Duration | 増加したいTTLを秒単位で指定します。 |

Go
Rust

resp, err := client.IncreaseTtl(ctx, &momento.IncreaseTtlRequest{
	CacheName: cacheName,
	Key:       momento.String("key"),
	Ttl:       time.Duration(9999),
})
if err != nil {
	panic(err)
}
switch resp.(type) {
case *responses.IncreaseTtlSet:
	log.Printf("Successfully increased TTL for key\n")
case *responses.IncreaseTtlMiss:
	log.Printf("Key does not exist in cache\n")
}

  match cache_client
      .increase_ttl(cache_name, "key", Duration::from_secs(5))
      .await?
  {
      IncreaseTtlResponse::Set => println!("TTL updated"),
      IncreaseTtlResponse::NotSet => println!("unable to increase TTL"),
      IncreaseTtlResponse::Miss => println!("Cache miss, unable to find key to increase TTL"),
  };

DecreaseTtl

TTLを減少させる場合のみ、keyのTTL秒数を指定された値に減らします。

例

TTLが5秒で、3秒を指定した場合、新しいTTLは3秒になります。
TTLが5秒で、6秒を指定した場合、TTLは減少しません。

名前	型	説明
cacheName	String	cacheの名前。
key	String \| Bytes	値のTTLを減少させるkeyの指定。
ttl	Duration	減少させたいTTLを秒単位で指定します。

Go
Rust

resp, err := client.DecreaseTtl(ctx, &momento.DecreaseTtlRequest{
	CacheName: cacheName,
	Key:       momento.String("key"),
	Ttl:       time.Duration(9999),
})
if err != nil {
	panic(err)
}
switch resp.(type) {
case *responses.DecreaseTtlSet:
	log.Printf("Successfully decreased TTL for key\n")
case *responses.DecreaseTtlMiss:
	log.Printf("Key does not exist in cache\n")
}

  match cache_client
      .decrease_ttl(cache_name, "key", Duration::from_secs(3))
      .await?
  {
      DecreaseTtlResponse::Set => println!("TTL updated"),
      DecreaseTtlResponse::NotSet => println!("unable to decrease TTL"),
      DecreaseTtlResponse::Miss => println!("Cache miss, unable to find key to decrease TTL"),
  };

ItemGetTtl

与えられたkeyに対して、そのアイテムがcacheから失効するまでの生存時間(TTL)を返します。

名前	型	説明
cacheName	String	cacheの名前。
key	String \| Byte	アイテムの型を返すkeyの指定。

メソッドのレスポンスオブジェクト

Cache hit

remainingTtl(): Duration

Cache miss
Cache error

具体的な情報については、レスポンスオブジェクトを参照してください。

Go
Rust

resp, err := client.ItemGetTtl(ctx, &momento.ItemGetTtlRequest{
	CacheName: cacheName,
	Key:       momento.String("key"),
})
if err != nil {
	panic(err)
}
switch r := resp.(type) {
case *responses.ItemGetTtlHit:
	log.Printf("TTL for key is %d\n", r.RemainingTtl().Milliseconds())
case *responses.ItemGetTtlMiss:
	log.Printf("Key does not exist in cache\n")
}

  let _remaining_ttl: Duration = cache_client
      .item_get_ttl(cache_name, "key")
      .await?
      .try_into()
      .expect("Expected an item ttl!");

認証API

これらのAPIは、Momentoの認証トークンやアクセスを管理するために使用されます。

GenerateApiKey

指定した権限と有効期限を持つ新しいMomento認証トークンを生成します。

名前	型	説明
scope	PermissionScope	新しいトークンに付与する権限です。あらかじめ構築されたTokenScope オブジェクトは、SDKによって提供されます。
expiresIn	ExpiresIn	トークンが期限切れになるまでの秒数、または`never`の指定。

メソッドのレスポンスオブジェクト

Success

authToken: string - the new auth token
refreshToken: string - a refresh token that can be used with the RefreshApiKey API to refresh the token before it expires
expiresAt: Timestamp - the timestamp at which the token will expire

Error

具体的な情報については、レスポンスオブジェクトを参照してください。

JavaScript
Go

// Generate a token that allows all data plane APIs on all caches and topics.
const allDataRWTokenResponse = await authClient.generateApiKey(AllDataReadWrite, ExpiresIn.minutes(30));
switch (allDataRWTokenResponse.type) {
  case GenerateApiKeyResponse.Success:
    console.log('Generated an API key with AllDataReadWrite scope!');
    // logging only a substring of the tokens, because logging security credentials is not advisable :)
    console.log(`API key starts with: ${allDataRWTokenResponse.apiKey.substring(0, 10)}`);
    console.log(`Refresh token starts with: ${allDataRWTokenResponse.refreshToken.substring(0, 10)}`);
    console.log(`Expires At: ${allDataRWTokenResponse.expiresAt.epoch()}`);
    break;
  case GenerateApiKeyResponse.Error:
    throw new Error(
      `An error occurred while attempting to call generateApiKey with AllDataReadWrite scope: ${allDataRWTokenResponse.errorCode()}: ${allDataRWTokenResponse.toString()}`
    );
}

// Generate a token that can only call read-only data plane APIs on a specific cache foo. No topic apis (publish/subscribe) are allowed.
const singleCacheROTokenResponse = await authClient.generateApiKey(
  TokenScopes.cacheReadOnly('foo'),
  ExpiresIn.minutes(30)
);
switch (singleCacheROTokenResponse.type) {
  case GenerateApiKeyResponse.Success:
    console.log('Generated an API key with read-only access to cache foo!');
    // logging only a substring of the tokens, because logging security credentials is not advisable :)
    console.log(`API key starts with: ${singleCacheROTokenResponse.apiKey.substring(0, 10)}`);
    console.log(`Refresh token starts with: ${singleCacheROTokenResponse.refreshToken.substring(0, 10)}`);
    console.log(`Expires At: ${singleCacheROTokenResponse.expiresAt.epoch()}`);
    break;
  case GenerateApiKeyResponse.Error:
    throw new Error(
      `An error occurred while attempting to call generateApiKey with single cache read-only scope: ${singleCacheROTokenResponse.errorCode()}: ${singleCacheROTokenResponse.toString()}`
    );
}

// Generate a token that can call all data plane APIs on all caches. No topic apis (publish/subscribe) are allowed.
const allCachesRWTokenResponse = await authClient.generateApiKey(
  TokenScopes.cacheReadWrite(AllCaches),
  ExpiresIn.minutes(30)
);
switch (allCachesRWTokenResponse.type) {
  case GenerateApiKeyResponse.Success:
    console.log('Generated an API key with read-write access to all caches!');
    // logging only a substring of the tokens, because logging security credentials is not advisable :)
    console.log(`API key starts with: ${allCachesRWTokenResponse.apiKey.substring(0, 10)}`);
    console.log(`Refresh token starts with: ${allCachesRWTokenResponse.refreshToken.substring(0, 10)}`);
    console.log(`Expires At: ${allCachesRWTokenResponse.expiresAt.epoch()}`);
    break;
  case GenerateApiKeyResponse.Error:
    throw new Error(
      `An error occurred while attempting to call generateApiKey with all caches read-write scope: ${allCachesRWTokenResponse.errorCode()}: ${allCachesRWTokenResponse.toString()}`
    );
}

// Generate a token that can call publish and subscribe on all topics within cache bar
const singleCacheAllTopicsRWTokenResponse = await authClient.generateApiKey(
  TokenScopes.topicPublishSubscribe({name: 'bar'}, AllTopics),
  ExpiresIn.minutes(30)
);
switch (singleCacheAllTopicsRWTokenResponse.type) {
  case GenerateApiKeyResponse.Success:
    console.log('Generated an API key with publish-subscribe access to all topics within cache bar!');
    // logging only a substring of the tokens, because logging security credentials is not advisable :)
    console.log(`API key starts with: ${singleCacheAllTopicsRWTokenResponse.apiKey.substring(0, 10)}`);
    console.log(`Refresh token starts with: ${singleCacheAllTopicsRWTokenResponse.refreshToken.substring(0, 10)}`);
    console.log(`Expires At: ${singleCacheAllTopicsRWTokenResponse.expiresAt.epoch()}`);
    break;
  case GenerateApiKeyResponse.Error:
    throw new Error(
      `An error occurred while attempting to call generateApiKey with read-write scope for all topics in a single cache: ${singleCacheAllTopicsRWTokenResponse.errorCode()}: ${singleCacheAllTopicsRWTokenResponse.toString()}`
    );
}

// Generate a token that can only call subscribe on topic where_is_mo within cache mo_nuts
const oneCacheOneTopicRWTokenResponse = await authClient.generateApiKey(
  TokenScopes.topicSubscribeOnly('mo_nuts', 'where_is_mo'),
  ExpiresIn.minutes(30)
);
switch (oneCacheOneTopicRWTokenResponse.type) {
  case GenerateApiKeyResponse.Success:
    console.log('Generated an API key with subscribe-only access to topic where_is_mo within cache mo_nuts!');
    // logging only a substring of the tokens, because logging security credentials is not advisable :)
    console.log(`API key starts with: ${oneCacheOneTopicRWTokenResponse.apiKey.substring(0, 10)}`);
    console.log(`Refresh token starts with: ${oneCacheOneTopicRWTokenResponse.refreshToken.substring(0, 10)}`);
    console.log(`Expires At: ${oneCacheOneTopicRWTokenResponse.expiresAt.epoch()}`);
    break;
  case GenerateApiKeyResponse.Error:
    throw new Error(
      `An error occurred while attempting to call generateApiKey with read-write scope for single topic in a single cache: ${oneCacheOneTopicRWTokenResponse.errorCode()}: ${oneCacheOneTopicRWTokenResponse.toString()}`
    );
}

// Generate a token with multiple permissions
const cachePermission1 = {
  role: CacheRole.ReadWrite, // Managed role that grants access to read as well as write apis on caches
  cache: 'acorns', // Scopes the access to a single cache named 'acorns'
};
const cachePermission2 = {
  role: CacheRole.ReadOnly, // Managed role that grants access to only read data apis on caches
  cache: AllCaches, // Built-in value for access to all caches in the account
};
const topicPermission1 = {
  role: TopicRole.PublishSubscribe, // Managed role that grants access to subscribe as well as publish apis
  cache: 'walnuts', // Scopes the access to a single cache named 'walnuts'
  topic: 'mo_favorites', // Scopes the access to a single topic named 'mo_favorites' within cache 'walnuts'
};
const topicPermission2 = {
  role: TopicRole.SubscribeOnly, // Managed role that grants access to only subscribe api
  cache: AllCaches, // Built-in value for all cache(s) in the account.
  topic: AllTopics, // Built-in value for access to all topics in the listed cache(s).
};

const permissions = {
  permissions: [cachePermission1, cachePermission2, topicPermission1, topicPermission2],
};

const multiplePermsTokenResponse = await authClient.generateApiKey(permissions, ExpiresIn.minutes(30));
switch (multiplePermsTokenResponse.type) {
  case GenerateApiKeyResponse.Success:
    console.log('Generated an API key with multiple cache and topic permissions!');
    // logging only a substring of the tokens, because logging security credentials is not advisable :)
    console.log(`API key starts with: ${multiplePermsTokenResponse.apiKey.substring(0, 10)}`);
    console.log(`Refresh token starts with: ${multiplePermsTokenResponse.refreshToken.substring(0, 10)}`);
    console.log(`Expires At: ${multiplePermsTokenResponse.expiresAt.epoch()}`);
    break;
  case GenerateApiKeyResponse.Error:
    throw new Error(
      `An error occurred while attempting to call generateApiKey with multiple permissions: ${multiplePermsTokenResponse.errorCode()}: ${multiplePermsTokenResponse.toString()}`
    );
}

// Generate a token that allows all data plane APIs on all caches and topics.
resp, err := authClient.GenerateApiKey(ctx, &momento.GenerateApiKeyRequest{
	ExpiresIn: utils.ExpiresInMinutes(30),
	Scope:     momento.AllDataReadWrite,
})
if err != nil {
	panic(err)
}
switch r := resp.(type) {
case *auth_resp.GenerateApiKeySuccess:
	log.Printf("Successfully generated an API key with AllDataReadWrite scope!\n")
	log.Printf("API key expires at: %d\n", r.ExpiresAt.Epoch())
}

// Generate a token that can only call read-only data plane APIs on a specific cache foo. No topic apis (publish/subscribe) are allowed.
resp, err = authClient.GenerateApiKey(ctx, &momento.GenerateApiKeyRequest{
	ExpiresIn: utils.ExpiresInMinutes(30),
	Scope:     momento.CacheReadOnly(momento.CacheName{Name: "foo"}),
})
if err != nil {
	panic(err)
}
switch r := resp.(type) {
case *auth_resp.GenerateApiKeySuccess:
	log.Printf("Successfully generated an API key with read-only access to cache foo!\n")
	log.Printf("API key expires at: %d\n", r.ExpiresAt.Epoch())
}

// Generate a token that can call all data plane APIs on all caches. No topic apis (publish/subscribe) are allowed.
resp, err = authClient.GenerateApiKey(ctx, &momento.GenerateApiKeyRequest{
	ExpiresIn: utils.ExpiresInMinutes(30),
	Scope:     momento.CacheReadWrite(momento.AllCaches{}),
})
if err != nil {
	panic(err)
}
switch r := resp.(type) {
case *auth_resp.GenerateApiKeySuccess:
	log.Printf("Successfully generated an API key with read-write access to all caches!\n")
	log.Printf("API key expires at: %d\n", r.ExpiresAt.Epoch())
}

// Generate a token that can call publish and subscribe on all topics within cache bar
resp, err = authClient.GenerateApiKey(ctx, &momento.GenerateApiKeyRequest{
	ExpiresIn: utils.ExpiresInMinutes(30),
	Scope:     momento.TopicPublishSubscribe(momento.CacheName{Name: "bar"}, momento.AllTopics{}),
})
if err != nil {
	panic(err)
}
switch r := resp.(type) {
case *auth_resp.GenerateApiKeySuccess:
	log.Printf("Successfully generated an API key publish-subscribe access to all topics within cache bar!\n")
	log.Printf("API key expires at: %d\n", r.ExpiresAt.Epoch())
}

// Generate a token that can only call subscribe on topic where_is_mo within cache mo_nuts
resp, err = authClient.GenerateApiKey(ctx, &momento.GenerateApiKeyRequest{
	ExpiresIn: utils.ExpiresInMinutes(30),
	Scope:     momento.TopicSubscribeOnly(momento.CacheName{Name: "mo_nuts"}, momento.TopicName{Name: "where_is_mo"}),
})
if err != nil {
	panic(err)
}
switch r := resp.(type) {
case *auth_resp.GenerateApiKeySuccess:
	log.Printf("Successfully generated an API key with subscribe-only access to topic where_is_mo within cache mo_nuts!\n")
	log.Printf("API key expires at: %d\n", r.ExpiresAt.Epoch())
}

// Generate a token with multiple permissions
cachePermission1 := momento.CachePermission{
	Cache: momento.CacheName{Name: "acorns"}, // Scopes the access to a single cache named 'acorns'
	Role:  momento.ReadWrite,                 // Managed role that grants access to read as well as write apis on caches
}
cachePermission2 := momento.CachePermission{
	Cache: momento.AllCaches{}, // Built-in value for access to all caches in the account
	Role:  momento.ReadOnly,    // Managed role that grants access to only read data apis on caches
}
topicPermission1 := momento.TopicPermission{
	Cache: momento.CacheName{Name: "walnuts"},      // Scopes the access to a single cache named 'walnuts'
	Topic: momento.TopicName{Name: "mo_favorites"}, // Scopes the access to a single topic named 'mo_favorites' within cache 'walnuts'
	Role:  momento.PublishSubscribe,                // Managed role that grants access to subscribe as well as publish apis
}
topicPermission2 := momento.TopicPermission{
	Cache: momento.AllCaches{},   // Built-in value for all cache(s) in the account.
	Topic: momento.AllTopics{},   // Built-in value for access to all topics in the listed cache(s).
	Role:  momento.SubscribeOnly, // Managed role that grants access to only subscribe api
}
permissions := []momento.Permission{
	cachePermission1, cachePermission2, topicPermission1, topicPermission2,
}

resp, err = authClient.GenerateApiKey(ctx, &momento.GenerateApiKeyRequest{
	ExpiresIn: utils.ExpiresInMinutes(30),
	Scope: momento.Permissions{
		Permissions: permissions,
	},
})
if err != nil {
	panic(err)
}
switch r := resp.(type) {
case *auth_resp.GenerateApiKeySuccess:
	log.Printf("Successfully generated an API key with multiple cache and topic permissions!\n")
	log.Printf("API key expires at: %d\n", r.ExpiresAt.Epoch())
}

RefreshApiKey

既存の有効期限内のMomento認証トークンを更新します。元のトークンと同じ権限と有効期限を持つ新しいトークンを生成します。

名前	型	説明
refreshToken	String	最初の`GenerateApiKey`の呼び出しから取得した、現在の認証トークンのrefreshTokenを指定。

メソッドのレスポンスオブジェクト

Success

authToken: string - the new auth token
refreshToken: string - a refresh token that can be used with the RefreshApiKey API to refresh the token before it expires
expiresAt: Timestamp - the timestamp at which the token will expire

Error

具体的な情報については、レスポンスオブジェクトを参照してください。

JavaScript
Go

const generateTokenResponse = await authClient.generateApiKey(AllDataReadWrite, ExpiresIn.minutes(30));

let successResponse: GenerateApiKey.Success;
switch (generateTokenResponse.type) {
  case GenerateApiKeyResponse.Success: {
    successResponse = generateTokenResponse;
    break;
  }
  case GenerateApiKeyResponse.Error:
    throw new Error(
      `An error occurred while attempting to call generateApiKey: ${generateTokenResponse.errorCode()}: ${generateTokenResponse.toString()}`
    );
}

console.log('Generated API key; refreshing!');
const refreshAuthClient = new AuthClient({
  credentialProvider: CredentialProvider.fromString({apiKey: successResponse.apiKey}),
});
const refreshTokenResponse = await refreshAuthClient.refreshApiKey(successResponse.refreshToken);
switch (refreshTokenResponse.type) {
  case RefreshApiKeyResponse.Success:
    console.log('API key refreshed!');
    // logging only a substring of the tokens, because logging security credentials is not advisable :)
    console.log(`Refreshed API key starts with: ${refreshTokenResponse.apiKey.substring(0, 10)}`);
    console.log(`New refresh token starts with: ${refreshTokenResponse.refreshToken.substring(0, 10)}`);
    console.log(`Refreshed API key expires At: ${refreshTokenResponse.expiresAt.epoch()}`);
    break;
  case RefreshApiKeyResponse.Error:
    throw new Error(
      `An error occurred while attempting to call refreshApiKey: ${refreshTokenResponse.errorCode()}: ${refreshTokenResponse.toString()}`
    );
}

resp, err := authClient.GenerateApiKey(ctx, &momento.GenerateApiKeyRequest{
	ExpiresIn: utils.ExpiresInMinutes(30),
	Scope:     momento.AllDataReadWrite,
})
if err != nil {
	panic(err)
}
generateApiKeySuccess := resp.(*auth_resp.GenerateApiKeySuccess)

newCredProvider, err := auth.FromString(generateApiKeySuccess.ApiKey)
if err != nil {
	panic(err)
}

refreshAuthClient, err := momento.NewAuthClient(config.AuthDefault(), newCredProvider)
if err != nil {
	panic(err)
}

refreshResp, err := refreshAuthClient.RefreshApiKey(ctx, &momento.RefreshApiKeyRequest{
	RefreshToken: generateApiKeySuccess.RefreshToken,
})
if err != nil {
	panic(err)
}
switch r := refreshResp.(type) {
case *auth_resp.RefreshApiKeySuccess:
	log.Printf("Successfully refreshed API key!\n")
	log.Printf("Refreshed API key expires at: %d\n", r.ExpiresAt.Epoch())
}

コレクションデータ型

コレクション型は、ユースケースに応じて、さまざまなタイプの構造を含むことができます。サポートされているデータ型は以下の通りです:

Dictionaries(辞書型)は、順序のないフィールドと値のペアを格納するために使用されます。
Lists(リスト型)は、順序付けられた要素のコレクションで、各要素が挿入された順序でソートされています。
Sets(セット型)は、ユニークな要素の文字列による、順序のないコレクションです。
Sorted Sets(ソート済みセット型) は、ユニークな要素の順序付きコレクションです。各要素は、値:スコアのペアを含んでいます。

利用方法についての詳しい情報は、コレクションデータ型をご覧ください。

Momento Cache API リファレンス

コントロールAPI​

Create cache​

Delete cache​

List caches​

Flush cache​

データAPI​

Set​

SetBatch​

Get​

GetBatch​

Delete​

Increment​

Ping​

ItemGetType​

KeyExists​

KeysExist​

SetIfAbsent​

SetIfPresent​

SetIfEqual​

SetIfNotEqual​

SetIfPresentAndNotEqual​

SetIfAbsentOrEqual​

生存時間(TTL)API​

UpdateTtl​

IncreaseTtl​

DecreaseTtl​

ItemGetTtl​

認証API​

GenerateApiKey​

RefreshApiKey​

コレクションデータ型​

コントロールAPI

Create cache

Delete cache

List caches

Flush cache

データAPI

Set

SetBatch

Get

GetBatch

Delete

Increment

Ping

ItemGetType

KeyExists

KeysExist

SetIfAbsent

SetIfPresent

SetIfEqual

SetIfNotEqual

SetIfPresentAndNotEqual

SetIfAbsentOrEqual

生存時間(TTL)API

UpdateTtl

IncreaseTtl

DecreaseTtl

ItemGetTtl

認証API

GenerateApiKey

RefreshApiKey

コレクションデータ型