Ignite C++ in-memory data grid has been built from the ground up with a notion of horizontal scale and ability to add nodes on demand in real-time; it has been designed to linearly scale to hundreds of nodes with strong semantics for data locality and affinity data routing to reduce redundant data noise.
Ignite data grid is an
in-memory distributed key-value store which can be viewed as a distributed partitioned hash map, with every cluster node owning a portion of the overall data. This way the more cluster nodes we add, the more data we can cache.
Unlike other key-value stores, Ignite determines data locality using a pluggable hashing algorithm. Every client can determine which node a key belongs to by plugging it into a hashing function, without a need for any special mapping servers or name nodes.
Ignite data grid supports local, replicated, and partitioned data sets and allows to freely cross query between these data sets using standard SQL syntax. Ignite supports standard SQL for querying in-memory data including support for distributed SQL joins.
Ignite data grid is lightning fast and is one of the fastest implementations of transactional or atomic data in a cluster today.
As long as your cluster is alive, Ignite will guarantee that the data between different cluster nodes will always remain consistent regardless of crashes or topology changes.
- Distributed In-Memory Caching
- Lightning Fast Performance
- Elastic Scalability
- Distributed In-Memory Transactions
- Tiered Off-Heap Storage
- Distributed ANSI-99 SQL Queries with support for Joins
Cache class is a gateway into Ignite cache implementation and provides methods for storing and retrieving data, executing queries, including SQL, iterating and scanning, etc.
You can obtain an instance of
Cache as follows:
using namespace ignite; using namespace cache; IgniteConfiguration cfg; // Start a node. Ignite grid = Ignition::Start(cfg); // Obtain instance of cache named "myCache". // Note that generic arguments are only for your convenience. // You can work with any cache in terms of any generic arguments. // However, attempt to retrieve an entry of incompatible type // will result in exception. Cache<int, std::string> cache = grid.GetCache<int, std::string>("myCache");
You can also create an instance of the cache on the fly, in which case Ignite will create and deploy the cache across all server cluster members.
using namespace ignite; using namespace cache; IgniteConfiguration cfg; // Start a node. Ignite grid = Ignition::Start(cfg); // Create cache with given name, if it does not exist. Cache<int, std::string> cache = grid.GetOrCreateCache<int, std::string>("myNewCache");
All caches defined in Ignite Spring XML configuration on any cluster member will also be automatically created and deployed on all the cluster servers (no need to specify the same configuration on each cluster member)