Access Patterns - Apache Ignite

SQL with Distributed Execution

ANSI SQL Support

Apache Ignite implements ANSI SQL with support for DDL (CREATE, ALTER, DROP), DML (SELECT, INSERT, UPDATE, DELETE, MERGE), and complex queries with joins, aggregations, and subqueries. The query planner generates distributed execution plans.

Distributed Query Execution

Queries execute across cluster nodes in parallel. The planner routes operations to nodes holding relevant partitions. Results stream back through the coordinator. This enables queries against datasets larger than any single node's memory.

Colocated Joins

When tables share colocation keys, joins execute locally without data movement. The colocateBy annotation in schema definitions enables this optimization. Colocated joins deliver join performance comparable to single-node databases at distributed scale.

JDBC Access

Apache Ignite provides standard JDBC drivers. Applications connect using familiar JDBC patterns. The driver implements automatic failover and connection pooling. This enables integration with existing tools and frameworks expecting JDBC connectivity.

Table API: Type-Safe Access

RecordView

RecordView provides typed access to complete table rows. Methods accept and return objects matching the table schema. The API handles serialization automatically. Use RecordView when working with full records or when type safety matters.

KeyValueView

KeyValueView separates key and value types for efficient partial updates. Operations specify only the columns involved. This reduces network traffic and serialization overhead. Use KeyValueView for high-throughput scenarios or targeted column updates.

Partition-Aware Routing

The Table API calculates partition ownership from keys. Operations route directly to nodes holding the data. No coordinator overhead. This single-hop access delivers minimal latency for point lookups and targeted updates.

Bulk Operations

Both RecordView and KeyValueView support batch operations. Methods like getAll, putAll, and deleteAll process multiple keys efficiently. The API groups operations by partition and executes them in parallel across relevant nodes.

Native Language APIs

Multi-Language Support

Apache Ignite provides native clients for Java, .NET, C++, Python, and other languages. Each client implements the same core APIs with language-specific patterns. Consistent functionality across languages enables polyglot architectures.

Protocol Efficiency

All clients communicate via an efficient binary protocol. The protocol minimizes serialization overhead and supports request pipelining. Partition awareness works identically across languages. This delivers consistent performance characteristics regardless of client language.

Transaction Support

SQL queries and Table API operations both support transactions. Begin transactions explicitly or use single-statement transactions. Choose isolation levels (REPEATABLE_READ or READ_COMMITTED). All access patterns provide the same transactional guarantees.

Async and Reactive APIs

The Table API offers asynchronous methods returning CompletableFuture. This enables non-blocking operations for high-concurrency scenarios. Reactive streams support backpressure for controlled data ingestion. Choose synchronous or asynchronous based on application requirements.

Use Cases

Operational Analytics

Run analytical SQL queries against operational data. Complex aggregations execute in parallel across cluster nodes. MVCC enables analytical queries while transactional updates proceed at full speed. No ETL to separate analytical systems.

View Use Case

High-Throughput Applications

Use KeyValueView for maximum throughput. Partition-aware routing delivers single-hop access. Batch operations process thousands of keys efficiently. Memory-first architecture provides microsecond-level latency for point operations.

View Use Case

Polyglot Architectures

Build systems with multiple languages accessing the same data. Java services use RecordView. Python analytics use SQL. .NET applications use KeyValueView. Consistent APIs and performance across all languages.

View Use Case

How Access Patterns Connect to the Foundation

Memory-First Operations

All access patterns execute against in-memory data. SQL queries, Table API operations, and native calls all benefit from memory-resident processing. No cache-miss penalties. No cache-warming strategies needed.

Learn About Storage

MVCC Enables Concurrent Access

MVCC allows SQL analytical queries and Table API updates to run simultaneously. Long-running aggregations work on stable snapshots. Transactional updates proceed at full throughput. Readers never block writers.

Learn About MVCC

Partition-Aware Routing

Table API and SQL both leverage partition awareness. Operations route directly to data owners. Colocated joins execute locally. This delivers minimal latency through single-hop access patterns.

Learn About Colocation