Update/Insert Existing Data in Cache

NCache provides the Insert() method and its overloads to facilitate updating objects in the cache. While it overwrites data for existing items, it also adds the item to the cache if the key does not exist in the cache.

Prerequisites

To learn about the standard prerequisites required to work with all NCache client side features please refer to the given page on Client Side API Prerequisites.
For API details refer to: ICache, CacheItemVersion, CacheItem, Insert, Get, InsertBulk, InsertAsync.

Update Object In Cache

You can update a custom object in the cache using various overloads of the Insert() method. This returns a CacheItemVersion.

Important

If the key already exists, it will overwrite the existing cache item with the same key.
If the key does not exist, the operation adds the item to the cache instead.

Note

To ensure the operation is fail-safe, it is recommended to handle any potential exceptions within your application, as explained in Handling Failures.

The following example gets values of an existing object and inserts it against the same key into the cache. If the key does not exist, it adds it to the cache.

try
{
    // Pre-condition: Cache is already connected

    // Get updated product from database against given product ID
    Product product = FetchProductFromDB(1001);

    // Insert Product object to cache
    CacheItemVersion version = cache.Insert("1001", product);

    // Item updated in cache successfully
}
catch (OperationFailedException ex)
{
    // Exception can occur due to:
    // Connection Failures
    // Operation Timeout
    // Operation performed during state transfer
}
catch (Exception ex)
{
    // Any generic exception like ArgumentNullException or ArgumentException
}

try
{
    // Pre-condition: Cache is already connected

    // Get product from database against given product ID
    Product product = fetchProductFromDB(1001);

    // Generate a unique cache key for this product
    String key = "Product:" + product.getProductID();

    // Insert Product object to cache
    CacheItemVersion version = cache.insert(key, product);

    // Item updated in cache successfully
}
catch (OperationFailedException ex)
{
    // NCache specific exception
    // Exception can occur due to:
    // Connection Failures
    // Operation Timeout
    // Operation performed during state transfer
}
catch (Exception ex)
{
    // Any generic exception like IllegalArgumentException or NullPointerException
}

try {
    // Pre-condition: Cache is already connected

    // Get product from database against given product ID
    val product = fetchProductFromDB(1001)

    // Generate a unique cache key for this product
    val key = "Product:" + product.getProductId

    // Insert Product object to cache
    val version = cache.insert(key, product)

    // Item updated in cache successfully
}
catch {
    case exception: Exception =>
    // Handle any errors
}

try
{
    // Pre-condition: Cache is already connected

    // Get product from database against given product ID
    product = await this.fetchProductFromDB();

    // Generate a unique cache key for this product
    var key = "Product:" + product.getProductID();

    // insert Product object to cache
    var version = await this.cache.insert(key, product);

    // Item added in cache successfully
}
catch(error)
{
    // Exception can occur due to:
    // Connection Failures
    // Operation Timeout
    // Operation performed during state transfer
}

try:
    # Pre-condition: Cache is already connected

    # Get product from database against given product ID
    product = fetch_product_from_db()

    # Generate a unique cache key for this product
    key = "Product:" + product.get_product_id()

    # Insert Product object to cache
    version = cache.insert(key, product)

    # Item inserted in cache successfully
except Exception as exp:
    # Handle errors

Update Object With Expiration

CacheItem is a custom class provided by NCache which can be used to add data to the cache and also lets you set additional specifications associated with an object as properties of this class. The CacheItem is updated in the cache against a unique key.

Important

If the key already exists, it will overwrite the existing cache item with the same key.
If the key does not exist, the operation adds the item to the cache instead.

The following example gets updated values of an existing CacheItem and inserts it against the same key into the cache. If the key does not exist, it adds it to the cache.

string customerKey = $"Customer:ALFKI";
Customer customer = FetchCustomerFromDB("ALFKI");

// Update Customer's Phone
customer.Phone = "0921-12 34 65";

// Cretae CacheItem
CacheItem cacheItem = new CacheItem(customer);
cacheItem.Expiration = new Expiration(ExpirationType.Sliding, TimeSpan.FromMinutes(5));

// Update cutsomer in DB and Cache
if (UpdateDB(customer))
{
    cache.Insert(customerKey, cacheItem);
}

// Get product from database against given product ID
Product product = fetchProductFromDB(1001);

// Generate a unique cache key for this product
String key = "Product:" + product.getProductID();

// Create a new CacheItem for this product
// You can OPTIONALLY specify multiple properties e.g. Priority, Expiration
// These properties are explained in successive chapters
CacheItem cacheItem = new CacheItem(product);

// Insert CacheItem to cache
CacheItemVersion version = cache.insert(key, cacheItem);

// Get product from database against given product ID
val product = fetchProductFromDB(1001)

// Generate a unique cache key for this product
val key = "Product:" + product.getProductId

// Create a new CacheItem for this product
// You can OPTIONALLY specify multiple properties e.g. Priority, DataExpiration
// These properties are explained in successive chapters
val cacheItem = new CacheItem(product)

// Insert CacheItem to cache
val version = cache.insert(key, cacheItem)

// Get product from database against given product ID
product = await this.fetchProductFromDB();

// Generate a unique cache key for this product
var key = "Product:" + product.getProductID();

// Create a new CacheItem for this product
// You can OPTIONALLY specify multiple properties e.g. Priority, Expiration
// These properties are explained in successive chapters
var cacheItem = new ncache.CacheItem(product);

// insert CacheItem to cache
var version = await this.cache.insert(key,cacheItem);

# Get product from database against given product ID
product = fetch_product_from_db()

# Generate a unique cache key for this product
key = "Product:" + product.get_product_id()

# Create a new CacheItem for this product
# You can OPTIONALLY specify multiple properties e.g.Priority, Expiration
# These properties are explained in successive chapters
cache_item = ncache.CacheItem(product)

# Insert CacheItem to cache
version = cache.insert(key, cache_item)

Update JsonObject in Cache

Note

This feature is only available in NCache Enterprise Edition.

You can update pre-existing Json data in the cache using Insert method.

For instance, you want to update an existing JsonObject by removing a particular attribute. This is done by using the Remove method which on providing with the attribute name, removes the attribute along with the value of the attribute. The success of removal can be identified via a flag returned by the RemoveAttribute call. A value of true indicates that the attribute was removed and vice versa. The only reason an attribute will not be removed is that the attribute does not exist.

Note

In order to use JsonValueBase, please add the following namespace in your application:

Alachisoft.NCache.Runtime.JSON

The following example removes the attribute UnitPrice from the JsonObject jsonProduct and then re-inserts the object in the cache.

// Pre-Condition: Cache is JSON serialized

string customerKey = $"Customer:ALFKI";

// Fetch from DB if not found in Cache
if (jsonCustomer == null)
{
    Customer customer = FetchCustomerFromDB("ALFKI");
    string customerJsonString = Newtonsoft.Json.JsonConvert.SerializeObject(customer);

    // Create a new JSON object from json string
    jsonCustomer = new JsonObject(customerJsonString);
}

// Remove the attribute and re-add updated attribute inJsonObject
jsonCustomer.RemoveAttribute("Phone");
jsonCustomer.AddAttribute("Phone", "0921-12 34 65");

// Update customer in DB and Cache
if (UpdateDB(jsonCustomer))
{
    cache.Insert(customerKey, jsonCustomer);
}

// Cache is JSON serialized
// A JsonObject `product` is added in the cache with various attributes

// Specify the cache key
String key = "Product:1001";

// Retrieve the added object against the specified key
JsonObject jsonProduct = cache.get(key,JsonObject.class);

// Remove the attribute UnitPrice from the JsonObject
boolean result = jsonProduct.removeAttribute("UnitPrice");
if (result == true)
{
    // Attribute is successfully removed
}
else
{
    // Wrong attribute name provided
}

// Re-insert the item in the cache with the removed attribute
cache.insert(key, jsonProduct);

// Cache is JSON serialized
// A JsonObject `product` is added in the cache with various attributes

// Specify the cache key
val key = "Product:1001"

// Retrieve the added object against the specified key
val jsonProduct = cache.get(key, classOf[JsonObject])

// Remove the attribute UnitPrice from the JsonObject
val result = jsonProduct.removeAttribute("UnitPrice")

if (result == true)
{
// Attribute is successfully removed
}
else
{
// Wrong attribute name provided
}

// Re-insert the item in the cache with the removed attribute
cache.insert(key, jsonProduct);

Update Bulk Items in Cache

InsertBulk() updates an array of CacheItem to the cache against the corresponding key. The method returns a dictionary of all the keys that failed to update, along with the failure reason.

Important

Any keys that fail to update and their failure reason will be returned as an IDictionary.

The following code example fetches an array of products (of Customer type) from the database. The products are then inserted to the cache as a dictionary of keys and CacheItem using InsertBulk().

// Create an array of all Customer Keys
String[] keys = new String[]
{
    "Customer:ALFKI", "Customer:ANATR", "Customer:ANTON", "Customer:AROUT", "Customer:BERGS"
};

// Get items from cache
IDictionary<string, Customer> itemsFetched = cache.GetBulk<Customer>(keys);

//Create a dictionary to store updated items
IDictionary<string, CacheItem> itemsUpdated = new Dictionary<string, CacheItem>();

// Update postal codes of dictionary items
foreach (KeyValuePair<string, Customer> item in itemsFetched)
{
    //Update Postal Code
    item.Value.PostalCode = "05023";

    // Create CacheItem of updated Customer object
    CacheItem updatedCacheItem = new CacheItem(item.Value);

    // Add uCacheItem to dictionary
    itemsUpdated.Add(item.Key,updatedCacheItem);
}

if (UpdateDB(itemsUpdated))
{
    // Insert updated bulk items to Cache
    IDictionary<string, Exception> keysFailedToInsert = cache.InsertBulk(itemsUpdated);

    if (keysFailedToInsert.Count > 0)
    {
        foreach (KeyValuePair<string, Exception> keyFailedToInsert in keysFailedToInsert)
            Console.WriteLine($"Could not update Item {keyFailedToInsert.Key} in cache due to error : {keyFailedToInsert.Value}");
    }
}

// Fetch all products from database
Product[] products = fetchProducts();

//Create Map of items to be added to cache
java.util.Map<String, CacheItem> itemsMap = new java.util.HashMap<String, CacheItem>();

for (Product product : products)
{
    String key = "Product:" + product.getProductID();
    CacheItem cacheItem = new CacheItem(product);

    //Add Map to cache
    itemsMap.put(key, cacheItem);
}

// Insert bulk data
java.util.Map<String, Exception> keysFailedToUpdate = cache.insertBulk(itemsMap);

//Check if keys failed to update
if (keysFailedToUpdate.size() > 0)
{
    for (java.util.Map.Entry<String, Exception> entry : keysFailedToUpdate.entrySet())
    {
        // Check failure reason
        if (entry.getValue() instanceof OperationFailedException)
        {
            // Any NCache specific exception
        }
    }
}

// Fetch all products from database
val products = fetchProducts

//Create Map of items to be added to cache
var itemsMap: Map[String, CacheItem] = Map()

for (product <- products) {
    val key = "Product:" + product.getProductId
    val cacheItem = new CacheItem(product)

    //Add Map to cache
    itemsMap = itemsMap + (key -> cacheItem)
}

// Insert bulk data
val keysFailedToUpdate = cache.insertBulk(itemsMap)

//Check if keys failed to update
if (keysFailedToUpdate.nonEmpty) {
    for (entry <- keysFailedToUpdate) {
    // Check failure reason
    }
}

// Fetch all products from database
var products = await this.fetchProductFromDB();

//Create map of items to be added to cache
var dictionary = new Map();

products.forEach(prod => {
    var key = "Product:" + this.product.getProductID();
    var cacheItem = new ncache.CacheItem(this.product);

    //insert dictionary to cache
    this.cache.insert(key,cacheItem);
});

var keysFailedToAdd = this.cache.addBulk(dictionary);

if(keysFailedToAdd.size() > 0)
{
    keysFailedToAdd.forEach(entry => {
        if(entry.getValue() == false)
        {
            var ex = false;
        }
        else
        {
            // Any other exception
        }
    });
}

# Fetch all products from database
products = fetch_products_from_db()

# Create map of items to be inserted to cache
dictionary = {}

for product in products:
    key = "Product:" + product.get_product_id()
    cache_item = ncache.CacheItem(product)

    # Add items to dictionary
    dictionary[key] = cache_item

keys_failed_to_insert = cache.insert_bulk(dictionary)

if len(keys_failed_to_insert) > 0:
    for entry in keys_failed_to_insert:
        if not keys_failed_to_insert[entry]:
            value = False
else:
    # Any other exception
    value = True

Update Objects with Asynchronous API

Note

This feature is only available in NCache Enterprise Edition.

InsertAsync returns object of the Task class which can further be used according to the business needs of the client application.

string customerKey = $"Customer:ALFKI";

// Get customer from database if not found in cache
if (customer == null)
    customer = FetchCustomerFromDB("ALFKI");

// Update customer's Phone
customer.Phone = "12345-6789";

// Update cutsomer in DB and Cache
if (UpdateDB(customer))
{
    //Adding item asynchronously.
    Task<CacheItemVersion> task = cache.InsertAsync(customerKey, customer);

    //This task object can be used as per your business needs
    if (task.IsCompleted)
    {
        // Get CacheItemVersion object from task result
        CacheItemVersion version = task.Result;
        Console.WriteLine($"Item {customer.CustomerID} has been updated with verion {version.Version}.");
    }
}

// Get product from database against given product ID
Product product = fetchProductFromDB(1001);

// Generate a unique cache key for this product
String key = "Product:" + product.getProductID();

// Create a CacheItem
CacheItem cacheItem = new CacheItem(product);

// Insert Product object to cache
FutureTask<CacheItemVersion> task = cache.insertAsync(key, cacheItem);

//This task object can be used as per your business needs
if (task.isDone())
{
    // Task completed
}

// Get product from database against given product ID
val product = fetchProductFromDB(1001)

// Generate a unique cache key for this product
val key = "Product:" + product.getProductId

// Create a CacheItem
val cacheItem = new CacheItem(product)

// Insert Product object to cache
val task = cache.insertAsync(key, cacheItem)

//This task object can be used as per your business needs
if (task.isCompleted) {
    // Task completed
}

# Get product from database
product = fetch_product_from_db()

# Generate a unique cache key for this product string
key = f"Product:{product.get_product_id()}"

# Insert Product object to cache asynchronously
async def insert_async():
    task = cache. insert_async("key", "product")
    value = await task

asyncio.run(insert_async())

# This task object can be used as per your business needs

Additional Resources

NCache provides a sample application for Basic Operations on GitHub.

Update/Insert Existing Data in Cache

Prerequisites

Update Object In Cache

Important

Note

Update Object With Expiration

Important

Update JsonObject in Cache

Note

Note

Update Bulk Items in Cache

Important

Update Objects with Asynchronous API

Note

Additional Resources

See Also