Key Value Store

As the Key Value Store is built on top of the JetStream persistence layer you obtain a KeyValueManager object from your JetStream context.

Creating, and deleting KV buckets

You can create as many independent key/value store instance, called ‘buckets’, as you need. Buckets are typically created, purged or deleted administratively (e.g. using the nats CLI tool), but this can also be done using one of the following KeyValueManager calls:

Go

  1. // KeyValue will lookup and bind to an existing KeyValue store.
  2. KeyValue(bucket string) (KeyValue, error)
  3. // CreateKeyValue will create a KeyValue store with the following configuration.
  4. CreateKeyValue(cfg *KeyValueConfig) (KeyValue, error)
  5. // DeleteKeyValue will delete this KeyValue store (JetStream stream).
  6. DeleteKeyValue(bucket string) error

Java

  1. /**
  2.  * Create a key value store.
  3.  * @param config the key value configuration
  4.  * @return bucket info
  5.  * @throws IOException covers various communication issues with the NATS
  6.  *         server such as timeout or interruption
  7.  * @throws JetStreamApiException the request had an error related to the data
  8.  * @throws IllegalArgumentException the server is not JetStream enabled
  9.  */
  10. KeyValueStatus create(KeyValueConfiguration config) throws IOException, JetStreamApiException;
  12. /**
  13. * Get the list of bucket names.
  14. * @return list of bucket names
  15. * @throws IOException covers various communication issues with the NATS
  16. *         server such as timeout or interruption
  17. * @throws JetStreamApiException the request had an error related to the data
  18. * @throws InterruptedException if the thread is interrupted
  19. */
  20. List<String> getBucketNames() throws IOException, JetStreamApiException, InterruptedException;
  22. /**
  23. * Gets the info for an existing bucket.
  24. * @param bucketName the bucket name to use
  25. * @throws IOException covers various communication issues with the NATS
  26. *         server such as timeout or interruption
  27. * @throws JetStreamApiException the request had an error related to the data
  28. * @return the bucket status object
  29. */
  30. KeyValueStatus getBucketInfo(String bucketName) throws IOException, JetStreamApiException;
  32. /**
  33. * Deletes an existing bucket. Will throw a JetStreamApiException if the delete fails.
  34. * @param bucketName the stream name to use.
  35. * @throws IOException covers various communication issues with the NATS
  36. *         server such as timeout or interruption
  37. * @throws JetStreamApiException the request had an error related to the data
  38. */
  39. void delete(String bucketName) throws IOException, JetStreamApiException;

JavaScript

  1.   static async create(
  2.     js: JetStreamClient,
  3.     name: string,
  4.     opts: Partial<KvOptions> = {},
  5.   ): Promise<KV>
  7. static async bind(
  8.     js: JetStreamClient,
  9.     name: string,
  10.     opts: Partial<{ codec: KvCodecs }> = {},
  11. ): Promise<KV>
  13. destroy(): Promise<boolean>

Python

  1. # from the JetStreamContext
  3. async def key_value(self, bucket: str) -> KeyValue:
  5. async def create_key_value(
  6.     self,
  7.     config: Optional[api.KeyValueConfig] = None,
  8.     **params,
  9. ) -> KeyValue:
  10.     """
  11.     create_key_value takes an api.KeyValueConfig and creates a KV in JetStream.
  12.     """
  14. async def delete_key_value(self, bucket: str) -> bool:
  15.     """
  16.     delete_key_value deletes a JetStream KeyValue store by destroying
  17.     the associated stream.
  18.     """

C

  1. NATS_EXTERN natsStatus     kvConfig_Init (kvConfig *cfg)
  2.      Initializes a KeyValue configuration structure.
  4. NATS_EXTERN natsStatus     js_CreateKeyValue (kvStore **new_kv, jsCtx *js, kvConfig *cfg)
  5.      Creates a KeyValue store with a given configuration.
  7. NATS_EXTERN natsStatus     js_KeyValue (kvStore **new_kv, jsCtx *js, const char *bucket)
  8.      Looks-up and binds to an existing KeyValue store.
  10. NATS_EXTERN natsStatus     js_DeleteKeyValue (jsCtx *js, const char *bucket)
  11.      Deletes a KeyValue store.
  13. NATS_EXTERN void     kvStore_Destroy (kvStore *kv)
  14.      Destroys a KeyValue store object.

C#

  1. /// <summary>
  2. /// Create a key value store.
  3. /// THIS IS A BETA FEATURE AND SUBJECT TO CHANGE
  4. /// </summary>
  5. /// <param name="config">the key value configuration</param>
  6. /// <returns></returns>
  7. KeyValueStatus Create(KeyValueConfiguration config);
  9. /// <summary>
  10. /// Get the list of bucket names.
  11. /// THIS IS A BETA FEATURE AND SUBJECT TO CHANGE
  12. /// </summary>
  13. /// <returns>list of bucket names</returns>
  14. IList<string> GetBucketNames();
  16. /// <summary>
  17. /// Gets the info for an existing bucket.
  18. /// THIS IS A BETA FEATURE AND SUBJECT TO CHANGE
  19. /// </summary>
  20. /// <param name="bucketName">the bucket name to use</param>
  21. /// <returns>the bucket status object</returns>
  22. KeyValueStatus GetBucketInfo(string bucketName);
  24. /// <summary>
  25. /// Deletes an existing bucket. Will throw a NATSJetStreamException if the delete fails.
  26. /// THIS IS A BETA FEATURE AND SUBJECT TO CHANGE
  27. /// </summary>
  28. /// <param name="bucketName"></param>
  29. void Delete(string bucketName);

{% endtabs %}

Getting

You can do a get to get the current value on a key, or ask to get a specific revision of the value.

Go

  1. // Get returns the latest value for the key.
  2. Get(key string) (entry KeyValueEntry, err error)
  3. // GetRevision returns a specific revision value for the key.
  4. GetRevision(key string, revision uint64) (entry KeyValueEntry, err error)

Java

  1. /**
  2. * Get the entry for a key
  3. * @param key the key
  4. * @return the KvEntry object or null if not found.
  5. * @throws IOException covers various communication issues with the NATS
  6. *         server such as timeout or interruption
  7. * @throws JetStreamApiException the request had an error related to the data
  8. * @throws IllegalArgumentException the server is not JetStream enabled
  9. */
  10. KeyValueEntry get(String key) throws IOException, JetStreamApiException;
  12. /**
  13. * Get the specific revision of an entry for a key.
  14. * @param key the key
  15. * @param revision the revision
  16. * @return the KvEntry object or null if not found.
  17. * @throws IOException covers various communication issues with the NATS
  18. *         server such as timeout or interruption
  19. * @throws JetStreamApiException the request had an error related to the data
  20. * @throws IllegalArgumentException the server is not JetStream enabled
  21. */
  22. KeyValueEntry get(String key, long revision) throws IOException, JetStreamApiException;

JavaScript %}

  1. async get(k: string): Promise<KvEntry | null>

Python

  1. async def get(self, key: str) -> Entry:
  2.    """
  3.    get returns the latest value for the key.
  4.    """

C

  1. NATS_EXTERN natsStatus     kvStore_Get (kvEntry **new_entry, kvStore *kv, const char *key)
  2.      Returns the latest entry for the key.
  4. NATS_EXTERN natsStatus     kvStore_GetRevision (kvEntry **new_entry, kvStore *kv, const char *key, uint64_t revision)
  5.      Returns the entry at the specific revision for the key.

C#

  1. /// <summary>
  2. /// Get the entry for a key
  3. /// THIS IS A BETA FEATURE AND SUBJECT TO CHANGE
  4. /// </summary>
  5. /// <param name="key">the key</param>
  6. /// <returns>The entry</returns>
  7. KeyValueEntry Get(string key);
  9. /// <summary>
  10. /// Get the specific revision of an entry for a key
  11. /// THIS IS A BETA FEATURE AND SUBJECT TO CHANGE
  12. /// </summary>
  13. /// <param name="key">the key</param>
  14. /// <param name="revision">the specific revision</param>
  15. /// <returns>The entry</returns>
  16. KeyValueEntry Get(string key, ulong revision);

{% endtabs %}

Putting

The key is always a string, you can simply use Put to store a byte array, or the convenience PutString to put a string. For ‘compare and set’ functionality you can use Create and Update.

Go

  1. Put(key string, value []byte) (revision uint64, err error)
  2. // PutString will place the string for the key into the store.
  3. PutString(key string, value string) (revision uint64, err error)
  4. // Create will add the key/value pair iff it does not exist.
  5. Create(key string, value []byte) (revision uint64, err error)
  6. // Update will update the value iff the latest revision matches.
  7. Update(key string, value []byte, last uint64) (revision uint64, err error)

Java

  1. /**
  2.  * Put a byte[] as the value for a key
  3.  * @param key the key
  4.  * @param value the bytes of the value
  5.  * @return the revision number for the key
  6.  * @throws IOException covers various communication issues with the NATS
  7.  *         server such as timeout or interruption
  8.  * @throws JetStreamApiException the request had an error related to the data
  9.  * @throws IllegalArgumentException the server is not JetStream enabled
  10.  */
  11. long put(String key, byte[] value) throws IOException, JetStreamApiException;
  13. /**
  14.  * Put a string as the value for a key
  15.  * @param key the key
  16.  * @param value the UTF-8 string
  17.  * @return the revision number for the key
  18.  * @throws IOException covers various communication issues with the NATS
  19.  *         server such as timeout or interruption
  20.  * @throws JetStreamApiException the request had an error related to the data
  21.  * @throws IllegalArgumentException the server is not JetStream enabled
  22.  */
  23. long put(String key, String value) throws IOException, JetStreamApiException;
  25. /**
  26.  * Put a long as the value for a key
  27.  * @param key the key
  28.  * @param value the number
  29.  * @return the revision number for the key
  30.  * @throws IOException covers various communication issues with the NATS
  31.  *         server such as timeout or interruption
  32.  * @throws JetStreamApiException the request had an error related to the data
  33.  * @throws IllegalArgumentException the server is not JetStream enabled
  34.  */
  35. long put(String key, Number value) throws IOException, JetStreamApiException;
  37. /**
  38.  * Put as the value for a key iff the key does not exist (there is no history)
  39.  * or is deleted (history shows the key is deleted)
  40.  * @param key the key
  41.  * @param value the bytes of the value
  42.  * @return the revision number for the key
  43.  * @throws IOException covers various communication issues with the NATS
  44.  *         server such as timeout or interruption
  45.  * @throws JetStreamApiException the request had an error related to the data
  46.  * @throws IllegalArgumentException the server is not JetStream enabled
  47.  */
  48. long create(String key, byte[] value) throws IOException, JetStreamApiException;
  50. /**
  51.  * Put as the value for a key iff the key exists and its last revision matches the expected
  52.  * @param key the key
  53.  * @param value the bytes of the value
  54.  * @param expectedRevision the expected last revision
  55.  * @return the revision number for the key
  56.  * @throws IOException covers various communication issues with the NATS
  57.  *         server such as timeout or interruption
  58.  * @throws JetStreamApiException the request had an error related to the data
  59.  * @throws IllegalArgumentException the server is not JetStream enabled
  60.  */
  61. long update(String key, byte[] value, long expectedRevision) throws IOException, JetStreamApiException;

JavaScript

  1.   async put(
  2.     k: string,
  3.     data: Uint8Array,
  4.     opts: Partial<KvPutOptions> = {},
  5.   ): Promise<number>
  7. create(k: string, data: Uint8Array): Promise<number>    
  9. update(k: string, data: Uint8Array, version: number): Promise<number>

Python

  1. async def put(self, key: str, value: bytes) -> int:
  2.     """
  3.     put will place the new value for the key into the store
  4.     and return the revision number.
  5.     """
  7. async def update(self, key: str, value: bytes, last: int) -> int:
  8.     """
  9.     update will update the value iff the latest revision matches.
  10.     """

C

  1. NATS_EXTERN natsStatus     kvStore_Put (uint64_t *rev, kvStore *kv, const char *key, const void *data, int len)
  2.      Places the new value for the key into the store.
  4. NATS_EXTERN natsStatus     kvStore_PutString (uint64_t *rev, kvStore *kv, const char *key, const char *data)
  5.      Places the new value (as a string) for the key into the store.
  7. NATS_EXTERN natsStatus     kvStore_Create (uint64_t *rev, kvStore *kv, const char *key, const void *data, int len)
  8.      Places the value for the key into the store if and only if the key does not exist.
  10. NATS_EXTERN natsStatus     kvStore_CreateString (uint64_t *rev, kvStore *kv, const char *key, const char *data)
  11.      Places the value (as a string) for the key into the store if and only if the key does not exist.
  13. NATS_EXTERN natsStatus     kvStore_Update (uint64_t *rev, kvStore *kv, const char *key, const void *data, int len, uint64_t last)
  14.      Updates the value for the key into the store if and only if the latest revision matches.
  16. NATS_EXTERN natsStatus     kvStore_UpdateString (uint64_t *rev, kvStore *kv, const char *key, const char *data, uint64_t last)
  17.      Updates the value (as a string) for the key into the store if and only if the latest revision matches.

C#

  1. /// <summary>
  2. /// Put a byte[] as the value for a key
  3. /// THIS IS A BETA FEATURE AND SUBJECT TO CHANGE
  4. /// </summary>
  5. /// <param name="key">the key</param>
  6. /// <param name="value">the bytes of the value</param>
  7. /// <returns>the revision number for the key</returns>
  8. ulong Put(string key, byte[] value);
  10. /// <summary>
  11. /// Put a string as the value for a key
  12. /// THIS IS A BETA FEATURE AND SUBJECT TO CHANGE
  13. /// </summary>
  14. /// <param name="key">the key</param>
  15. /// <param name="value">the UTF-8 string</param>
  16. /// <returns>the revision number for the key</returns>
  17. ulong Put(string key, string value);
  19. /// <summary>
  20. ///Put a long as the value for a key
  21. /// THIS IS A BETA FEATURE AND SUBJECT TO CHANGE
  22. /// </summary>
  23. /// <param name="key">the key</param>
  24. /// <param name="value">the number</param>
  25. /// <returns>the revision number for the key</returns>
  26. ulong Put(string key, long value);
  28. /// <summary>
  29. /// Put as the value for a key iff the key does not exist (there is no history)
  30. /// or is deleted (history shows the key is deleted)
  31. /// THIS IS A BETA FEATURE AND SUBJECT TO CHANGE
  32. /// </summary>
  33. /// <param name="key">the key</param>
  34. /// <param name="value">the bytes of the value</param>
  35. /// <returns>the revision number for the key</returns>
  36. ulong Create(string key, byte[] value);
  38. /// <summary>
  39. /// Put as the value for a key iff the key exists and its last revision matches the expected
  40. /// THIS IS A BETA FEATURE AND SUBJECT TO CHANGE
  41. /// </summary>
  42. /// <param name="key">the key</param>
  43. /// <param name="value">the bytes of the value</param>
  44. /// <param name="expectedRevision"></param>
  45. /// <returns>the revision number for the key</returns>
  46. ulong Update(string key, byte[] value, ulong expectedRevision);

{% endtabs %}

Deleting

You can delete a specific key, or purge the whole key/value bucket.

Go

  1. // Delete will place a delete marker and leave all revisions.
  2. Delete(key string) error
  3. // Purge will place a delete marker and remove all previous revisions.
  4. Purge(key string) error

Java

  1. /**
  2. * Soft deletes the key by placing a delete marker.
  3. * @param key the key
  4. * @throws IOException covers various communication issues with the NATS
  5. *         server such as timeout or interruption
  6. * @throws JetStreamApiException the request had an error related to the data
  7. */
  8. void delete(String key) throws IOException, JetStreamApiException;
  10. /**
  11. * Purge all values/history from the specific key
  12. * @param key the key
  13. * @throws IOException covers various communication issues with the NATS
  14. *         server such as timeout or interruption
  15. * @throws JetStreamApiException the request had an error related to the data
  16. */
  17. void purge(String key) throws IOException, JetStreamApiException;

JavaScript

  1. delete(k: string): Promise<void>
  3. purge(k: string): Promise<void>

Python

  1. async def delete(self, key: str) -> bool:
  2.     """
  3.     delete will place a delete marker and remove all previous revisions.
  4.     """
  6. async def purge(self, key: str) -> bool:
  7.     """
  8.     purge will remove the key and all revisions.
  9.     """

C

  1. NATS_EXTERN natsStatus     kvStore_Delete (kvStore *kv, const char *key)
  2.      Deletes a key by placing a delete marker and leaving all revisions.
  4. NATS_EXTERN natsStatus     kvStore_Purge (kvStore *kv, const char *key, kvPurgeOptions *opts)
  5.      Deletes a key by placing a purge marker and removing all revisions.
  7. NATS_EXTERN natsStatus     kvStore_PurgeDeletes (kvStore *kv, kvPurgeOptions *opts)
  8.      Purge and removes delete markers.

C#

  1. /// <summary>
  2. /// Soft deletes the key by placing a delete marker. 
  3. /// THIS IS A BETA FEATURE AND SUBJECT TO CHANGE
  4. /// </summary>
  5. /// <param name="key">the key</param>
  6. void Delete(string key);
  8. /// <summary>
  9. /// Purge all values/history from the specific key. 
  10. /// THIS IS A BETA FEATURE AND SUBJECT TO CHANGE
  11. /// </summary>
  12. /// <param name="key">the key</param>
  13. void Purge(string key);
  15. /// <summary>
  16. /// Remove history from all keys that currently are deleted or purged,
  17. /// using a default KeyValuePurgeOptions
  18. /// THIS IS A BETA FEATURE AND SUBJECT TO CHANGE
  19. /// </summary>
  20. void PurgeDeletes();
  22. /// <summary>
  23. /// Remove history from all keys that currently are deleted or purged
  24. /// THIS IS A BETA FEATURE AND SUBJECT TO CHANGE
  25. /// </summary>
  26. void PurgeDeletes(KeyValuePurgeOptions options);

{% endtabs %}

Getting all the keys

You can get the list of all the keys currently having a value associated using Keys()

Go

  1. // Keys will return all keys.
  2. Keys(opts ...WatchOpt) ([]string, error)

Java

  1. /**
  2.  * Get a list of the keys in a bucket.
  3.  * @return List of keys
  4.  * @throws IOException covers various communication issues with the NATS
  5.  *         server such as timeout or interruption
  6.  * @throws JetStreamApiException the request had an error related to the data
  7.  * @throws InterruptedException if the thread is interrupted
  8.  */
  9. List<String> keys() throws IOException, JetStreamApiException, InterruptedException;

JavaScript

  1. async keys(k = ">"): Promise<QueuedIterator<string>>

C

  1. NATS_EXTERN natsStatus     kvStore_Keys (kvKeysList *list, kvStore *kv, kvWatchOptions *opts)
  2.      Returns all keys in the bucket.
  4. NATS_EXTERN void     kvKeysList_Destroy (kvKeysList *list)
  5.      Destroys this list of KeyValue store key strings.

C#

  1. /// <summary>
  2. /// Get a list of the keys in a bucket.
  3. /// THIS IS A BETA FEATURE AND SUBJECT TO CHANGE
  4. /// </summary>
  5. /// <returns>The list of keys</returns>
  6. IList<string> Keys();

{% endtabs %}

Getting the history for a key

The JetStream key/value store has a feature you don’t usually find in key/value stores: the ability to keep a history of the values associated with a key (rather than just the current value). The depth of the history is specified when the key/value bucket is created, and the default is a history depth of 1 (i.e. no history).

Go

  1. // History will return all historical values for the key.
  2. History(key string, opts ...WatchOpt) ([]KeyValueEntry, error)

Java

  1. /**
  2.  * Get the history (list of KeyValueEntry) for a key
  3.  * @param key the key
  4.  * @return List of KvEntry
  5.  * @throws IOException covers various communication issues with the NATS
  6.  *         server such as timeout or interruption
  7.  * @throws JetStreamApiException the request had an error related to the data
  8.  * @throws InterruptedException if the thread is interrupted
  9.  */
  10. List<KeyValueEntry> history(String key) throws IOException, JetStreamApiException, InterruptedException;

JavaScript

  1. async history(
  2.     opts: { key?: string; headers_only?: boolean } = {},
  3.   ): Promise<QueuedIterator<KvEntry>>

C

  1. NATS_EXTERN natsStatus     kvStore_History (kvEntryList *list, kvStore *kv, const char *key, kvWatchOptions *opts)
  2.      Returns all historical entries for the key.
  4. NATS_EXTERN void     kvEntryList_Destroy (kvEntryList *list)
  5.      Destroys this list of KeyValue store entries.

C#

  1. /// <summary>
  2. /// Get the history (list of KeyValueEntry) for a key
  3. /// THIS IS A BETA FEATURE AND SUBJECT TO CHANGE
  4. /// </summary>
  5. /// <param name="key">the key</param>
  6. /// <returns>The list of KeyValueEntry</returns>
  7. IList<KeyValueEntry> History(string key);

{% endtabs %}

Watching for changes

Watching a key/value bucket is like subscribing to updates: you provide a callback and you can watch all of the keys in the bucket or specify which specific key(s) you want to be kept updated about.

Go

  1. // Watch for any updates to keys that match the keys argument which could include wildcards.
  2. // Watch will send a nil entry when it has received all initial values.
  3. Watch(keys string, opts ...WatchOpt) (KeyWatcher, error)
  4. // WatchAll will invoke the callback for all updates.
  5. WatchAll(opts ...WatchOpt) (KeyWatcher, error)

Java

  1. /**
  2.  * Watch updates for a specific key
  3.  * @param key the key
  4.  * @param watcher the watcher
  5.  * @param watchOptions the watch options to apply. If multiple conflicting options are supplied, the last options wins.
  6.  * @return The KeyValueWatchSubscription
  7.  * @throws IOException covers various communication issues with the NATS
  8.  *         server such as timeout or interruption
  9.  * @throws JetStreamApiException the request had an error related to the data
  10.  * @throws InterruptedException if the thread is interrupted
  11.  */
  12. NatsKeyValueWatchSubscription watch(String key, KeyValueWatcher watcher, KeyValueWatchOption... watchOptions) throws IOException, JetStreamApiException, InterruptedException;
  14. /**
  15.  * Watch updates for all keys
  16.  * @param watcher the watcher
  17.  * @param watchOptions the watch options to apply. If multiple conflicting options are supplied, the last options wins.
  18.  * @return The KeyValueWatchSubscription
  19.  * @throws IOException covers various communication issues with the NATS
  20.  *         server such as timeout or interruption
  21.  * @throws JetStreamApiException the request had an error related to the data
  22.  * @throws InterruptedException if the thread is interrupted
  23.  */
  24. NatsKeyValueWatchSubscription watchAll(KeyValueWatcher watcher, KeyValueWatchOption... watchOptions) throws IOException, JetStreamApiException, InterruptedException;

JavaScript

  1.   async watch(
  2.     opts: {
  3.       key?: string;
  4.       headers_only?: boolean;
  5.       initializedFn?: callbackFn;
  6.     } = {},
  7.   ): Promise<QueuedIterator<KvEntry>>

C

  1. NATS_EXTERN natsStatus     kvStore_Watch (kvWatcher **new_watcher, kvStore *kv, const char *keys, kvWatchOptions *opts)
  2.      Returns a watcher for any updates to keys that match the keys argument.
  4. NATS_EXTERN natsStatus     kvStore_WatchAll (kvWatcher **new_watcher, kvStore *kv, kvWatchOptions *opts)
  5.      Returns a watcher for any updates to any keys of the KeyValue store bucket.

C#

  1. /// <summary>
  2. /// Watch updates for a specific key
  3. /// THIS IS A BETA FEATURE AND SUBJECT TO CHANGE
  4. /// WARNING: This api requires an internal consumer the enforces ordering of messages.
  5. /// This portion of the implementation is not complete yet. If there was some sort of
  6. /// error from the server and messages were skipped or came out of order the data received
  7. /// would be incomplete. While this is an edge case, it can still technically happen. 
  8. /// </summary>
  9. /// <param name="key">the key</param>
  10. /// <param name="watcher">the watcher</param>
  11. /// <param name="watchOptions">the watch options to apply. If multiple conflicting options are supplied, the last options wins.</param>
  12. /// <returns></returns>
  13. KeyValueWatchSubscription Watch(string key, IKeyValueWatcher watcher, params KeyValueWatchOption[] watchOptions);
  15. /// <summary>
  16. /// Watch updates for all keys
  17. /// THIS IS A BETA FEATURE AND SUBJECT TO CHANGE
  18. /// WARNING: This api requires an internal consumer the enforces ordering of messages.
  19. /// This portion of the implementation is not complete yet. If there was some sort of
  20. /// error from the server and messages were skipped or came out of order the data received
  21. /// would be incomplete. While this is an edge case, it can still technically happen. 
  22. /// </summary>
  23. /// <param name="watcher">the watcher</param>
  24. /// <param name="watchOptions">the watch options to apply. If multiple conflicting options are supplied, the last options wins.</param>
  25. /// <returns>The KeyValueWatchSubscription</returns>
  26. KeyValueWatchSubscription WatchAll(IKeyValueWatcher watcher, params KeyValueWatchOption[] watchOptions);

{% endtabs %}