• Webinars
  • Docs
  • Download
  • Blogs
  • Contact Us
Show / Hide Table of Contents
  • Programmer's Guide
  • Client Side API Programming
    • Setting Up Development Environment
    • Basic Cache Operations
      • Initialize Cache
      • Add Data to Cache
      • Update Data in Cache
      • Fetch Data From Cache
      • Remove Data From Cache
      • Dispose Cache
    • Bulk Operations
      • Adding Collection to Cache
      • Updating Collection in Cache
      • Retrieving Collection from Cache
      • Removing Collection from Cache
      • Deleting Collection from Cache
    • Asynchronous Operations
      • Using Asynchronous Operations
      • Using Asynchronous Operations with Callback Methods
    • Groups and Subgroups
      • Adding/Updating Data Group in Cache
      • Retrieving Data Group from Cache
      • Removing Data Group from Cache
    • Tagging Data in NCache
      • Creating Tags
      • Adding Items with Tags
      • Retrieving Previously Tagged Data
      • Removing Tagged Items from Cache
    • Named Tags
    • Data Expiration Strategies
      • Using Absolute Expiration
      • Using Sliding Expiration
    • Cache Dependencies
      • Key Dependency
      • File Dependency
      • Notification based Dependencies
        • Database Dependency using SQL Server
        • Database Dependency using Oracle
      • Polling Based Dependency
      • Custom Data Source Dependency
      • Multiple Cache Sync Dependency
      • Aggregate Dependency
      • Add Dependency to Existing Item
      • Using CLR Procedures to Call NCache
    • Locking Data in NCache
      • Locking Items in Cache (Pessimistic Locking)
      • Locking Items with Cache Item Versioning (Optimistic Locking)
    • SQL Reference for NCache
      • SQL Syntax
      • Querying Samples for Operators
      • Querying Data in NCache
      • NCache Language Integrated Query (LINQ)
        • Using LINQ in NCache
        • Configuring LINQPad for NCache
        • Querying NCache Data in LINQPad
    • Event Notifications
      • Cache Level Event Notifications
      • Item Level Event Notifications
      • Custom Event Notifications
    • Publish/Subscribe (Pub/Sub) in NCache
      • Pub/Sub Topics
      • Managing Topics
      • Pub/Sub Messages
        • Message Behavior and Properties
        • Creating a Message
      • Publish Messages to Topic
      • Subscribe for Topic Messages
      • Monitoring Pub/Sub Topics
    • Continuous Query
    • Using Streams in NCache
      • Opening with Stream Modes
      • Adding and Updating Data with Streams
      • Retrieving Data from Streams
      • Closing a Stream
    • Security and Encryption
      • NCache Security
      • NCache Data Encryption
    • Data Compression
    • NCache Management API
  • Server Side API Programming
    • Cache Startup Loader
      • Components of Cache Startup Loader
      • Sample Implementation of ICacheLoader on Single Node
      • Sample Implementation of ICacheLoader with Distribution Hints
    • Data Source Providers (Backing Source)
      • Read-Through Caching
        • Configure Read-Through Provider
        • Using Read-Through with Cache Operations
      • Write-Through Caching
        • Configuring Write-Through Provider
        • Using Write-Through with Basic Operations
        • Using Write-Behind with Basic Operations
        • Using Write-Behind with Bulk Operations
        • Using Write-Behind with Async Operations
        • Monitor Write-Through Counters
    • Custom Dependency
      • Sample Implementation of Custom Dependency
      • Sample Usage of Custom Dependency
    • WAN Replication through Bridge
      • Bridge Configurations
      • Implementing Bridge Conflict Resolver
    • Entry Processor
      • Sample Implementation of IEntryProcessor Interface
      • Sample Usage of EntryProcessor
    • MapReduce
      • Sample Implementation of MapReduce Interfaces
      • Sample Usage of MapReduce
    • Aggregator
      • Sample Implementation of IValueExtractor Interface
      • Sample Implementation of IAggregator Interface
      • Sample Usage of Aggregator
    • Dynamic Compact Serialization
  • Client Side ASP.NET Features
    • ASP.NET
      • ASP.NET Session State Provider for NCache
      • Multi-Region ASP.NET Session State Provider for NCache
    • ASP.NET Core
      • Session Storage in ASP.NET Core
        • Configure NCache ASP.NET Core Session Provider
        • Configure ASP.NET Core Sessions with NCache IDistributedCache Provider
      • Multi-Region ASP.NET Core Session Provider for NCache
      • Object Caching in ASP.NET Core
    • ASP.NET SignalR
      • Using NCache Extension for SignalR
    • View State Caching
      • Configuring and Using Content Optimization
      • Group View State with Sessions
      • Limit View State Caching
      • Perform Page Level Grouping for View State
    • ASP.NET Output Cache
      • Configure ASP.NET Output Caching
      • Using ASP.NET Output Cache with Custom Hooks
  • Client Side Third Party Integrations
    • Migrating AppFabric to NCache
      • AppFabric API vs. NCache API
    • NHibernate
      • NCache as NHibernate Second Level Cache
      • Using NHibernate Query Caching
      • Configuring Database Synchronization with NHibernate
    • Entity Framework Caching Integration
      • NCache as Entity Framework Second Level Cache
      • Entity Framework Caching Config File
    • Entity Framework Core Caching
      • Installing NCache Entity Framework Core Provider
      • Configuring NCache Entity Framework Core Provider
      • Using NCache Entity Framework Core Provider
        • Caching Options for EF Core Provider
        • LINQ APIs for EF Core Provider
        • Cache Only APIs for EF Core Provider
        • Query Deferred APIs for EF Core Provider
      • Logging in NCache Entity Framework Core Provider
    • Memcached
      • NCache Memcached Gateway Approach
      • Memcached Client Plugin for .NET
    • Debug NCache Providers in Visual Studio
    • NCache for Visual Studio Extension

Querying Samples for Operators

Using Equal (=) Operator

string query = "SELECT Product where this.ProductID = ?";
Hashtable values = new Hashtable();
values.Add("ProductID", 1001);
try
{    
  ICacheReader reader = cache.ExecuteReader(query, values);    
  if (reader.FieldCount > 0){      
    while (reader.Read()){            
       Product result = (Product)reader.GetValue(1); //perform operations        
    }    
  }    
  else{       
        //no record exists    
  }    
    reader.Close();
  }
catch(Exception ex)
{
    // handle exception
}

Using Multiple Operators

string query = "SELECT Product where this.ProductID < ? AND this.Category = ?";
Hashtable values = new Hashtable();
values.Add("ProductID", 1002);
values.Add("Category", 4);
try
{    
      ICacheReader reader = cache.ExecuteReader(query, values);    
      if (reader.FieldCount > 0)
      {
        while (reader.Read()){    
          Product result = (Product)reader.GetValue(1);    //perform operations
        }
      }    
      else
      {
        //no record exists
      }    
      reader.Close();
}
catch (Exception ex)
{
    //handle exception
} 

Using IN Operator

 string query = "SELECT Product where this.ProductID IN (?,?,?)";
ArrayList idList = new ArrayList();
idList.Add(1001);
idList.Add(100);
idList.Add(500);Hashtable values = new Hashtable();
values.Add("ProductID", idList);
try
{
    ICacheReader reader = cache.ExecuteReader(query, values);
    if (reader.FieldCount > 0)
    {
      while (reader.Read())
      {            
        Product result = (Product)reader.GetValue(1);    //perform operations
      }
    }
    else
    {
      //no record exists
    }    
    reader.Close();}
catch (Exception ex)
{
    // handle exception
}

Using LIKE Operator

string query = "SELECT Product where this.ProductName LIKE ?";
ArrayList list = new ArrayList();
list.Add("Ch*");

Hashtable values = new Hashtable();
values.Add("ProductName", list);
try
{
    ICacheReader reader = cache.ExecuteReader(query, values);
    if (reader.FieldCount > 0)
    {
      while (reader.Read())
      {            
        Product result = (Product)reader.GetValue(1);    //perform operations
      }
    }
    else
    {
      //no record exists
    }    
    reader.Close();
}
catch (Exception ex){
    // handle exception
} 

Using GROUP BY Clause

Note that the GROUP BYclause cannot be used without an Aggregate function.

string query = "SELECT this.Category, COUNT(Product) WHERE this.ProductID > ? GROUP BY this.Category";

Hashtable values = new Hashtable();
values.Add("ProductID", 5);
try
{
    ICacheReader reader = cache.ExecuteReader(query, values);
    if (reader.FieldCount > 0)
    {
      while (reader.Read())
      {    
        object category = reader.GetOrdinal("Category");    object result = reader.GetValue(1);    //perform operations        
      }
    }    
    else
    {
      //no record exists
    }    
    reader.Close();
}
catch(Exception ex){
    // handle exception
}

Using ORDER BY Clause

string query = "SELECT Product ORDER BY by this.ProductID = ?";

//OR

string query = "SELECT Product WHERE this.Category = ? ORDER BY this.Category";

Hashtable values = new Hashtable();
values.Add("ProductID", 1001);

try
{
    ICacheReader reader = cache.ExecuteReader(query, values);
    if (reader.FieldCount > 0)
    {
       while (reader.Read())
       {     Product result = (Product)reader.GetValue(1);
         //perform operations
      }
    }
   else
   {
        //no record exists
   }
   reader.Close();
}
catch (OperationFailedException ex)
{
  // handle exception
}

Using DELETE Statement

The Delete statement can only be executed through ExecuteNonQuery:

string query = "DELETE Product WHERE this.ProductID > ?";
Hashtable values = new Hashtable();
values.Add("ProductID", 5);
try
{
    int result = cache.ExecuteNonQuery(query, values);
    //return number of affected rows.
}
catch(Exception ex)
{
    // handle exception
}
Back to top Copyright © 2017 Alachisoft