How do I use CQEngine with Spring Boot?

Integrate CQEngine by creating IndexedCollection beans and defining attributes for your entities. There's no out-of-the-box starter, so you'll need to manage configuration manually, but it works seamlessly with Java collections in Spring contexts.

CQEngine vs Java Streams for filtering collections?

CQEngine outperforms Java Streams by orders of magnitude for large datasets due to indexing, reducing time complexity from O(n) to O(1) for indexed queries. Use Streams for simple transformations, but CQEngine for high-performance querying.

How to handle null values in CQEngine attributes?

Use SimpleNullableAttribute or MultiValueNullableAttribute to properly handle null values, as non-nullable attributes can throw NullPointerException. The README warns about this and recommends nullable attributes for uncertain data.

Does CQEngine support full-text search like Lucene?

CQEngine supports string matching via indexes like SuffixTree for contains or endsWith queries, but it lacks advanced full-text features such as stemming or relevance scoring. For complex text search, consider integrating with Lucene or Elasticsearch.

How to persist CQEngine collections to a database?

CQEngine itself handles on-heap, off-heap, or disk persistence, but for database storage, you'd need to sync data manually or use it as a cache layer. The README shows integration with ORMs for querying database-loaded collections.

What's the performance impact of off-heap persistence?

Off-heap persistence reduces Java heap usage but may introduce higher latency compared to on-heap, as data is stored in native memory. The README notes it's slower than on-heap but faster than disk, suitable for large datasets.

Open-Awesome

CQEngine

Apache-2.0Java

A high-performance Java collection engine enabling SQL-like queries with indexes for microsecond latencies.

GitHub

1.8k stars254 forks0 contributors

What is CQEngine?

CQEngine is a high-performance Java library that enables SQL-like queries on in-memory collections with indexes, achieving microsecond latencies. It solves the problem of slow iterative searches by building indexes on object fields, allowing developers to offload query traffic from databases and scale application tiers efficiently.

Target Audience

Java developers building data-intensive applications that require fast querying of in-memory collections, such as real-time analytics, caching layers, or middleware needing low-latency data access.

Value Proposition

Developers choose CQEngine for its ability to outperform traditional iteration by thousands of times, support for multiple index types and persistence options, and seamless integration with existing Java collections without requiring external databases.

Overview

Ultra-fast SQL-like queries on Java collections

Use Cases

Best For

Building in-memory caches with complex query requirements
Offloading query processing from relational databases to reduce latency
Implementing real-time filtering and search on Java collections
Handling large datasets with low-latency range and equality queries
Developing high-performance middleware for data-intensive applications
Creating scalable Java applications that require concurrent querying and updates

Not Ideal For

Applications with extremely small datasets where linear iteration overhead is negligible
Systems requiring distributed query processing across multiple nodes or clusters
Use cases needing advanced full-text search features like stemming, synonyms, or fuzzy matching
Teams seeking a zero-configuration, drop-in library without manual attribute and index management

Pros & Cons

Pros

Microsecond Query Latency

Achieves millions of queries per second with latencies in microseconds, as benchmarked in the README showing over 1 million QPS on a single core.

Diverse Index Support

Offers multiple index types like hash, navigable, and suffix tree indexes, enabling efficient equality, range, and string matching queries for various scenarios.

Flexible Persistence Layers

Supports on-heap, off-heap, and disk persistence, allowing large collections with minimal heap usage, tested with up to 100 million objects on disk.

Concurrent and Transactional

Provides lock-free concurrent reads and MVCC transaction isolation for real-time updates, as detailed in the TransactionIsolation documentation.

Cons

Attribute Definition Overhead

Requires manual definition of attributes for each field to be indexed, which can be verbose and error-prone, especially for complex or nested objects.

Index Memory Consumption

Building indexes increases memory usage, which might be prohibitive for memory-constrained environments or when scaling to very large datasets with many indexes.

Limited Ecosystem Integration

While it integrates with ORMs like Hibernate, there's less built-in support for modern frameworks like Spring Boot or cloud-native tools, requiring custom integration efforts.

Frequently Asked Questions

Related Projects

Design Patterns implemented in Java

Design patterns implemented in Java

Stars94,101

Forks27,363

Last commit1 day ago

FizzBuzz Enterprise Edition

FizzBuzz Enterprise Edition is a no-nonsense implementation of FizzBuzz made by serious businessmen for serious business purposes.

Stars23,698

Forks804

Last commit1 year ago

Modern Java - A Guide to Java 8

Stars16,734

Forks4,007

Last commit2 years ago

Testcontainers

Testcontainers is a Java library that supports JUnit tests, providing lightweight, throwaway instances of common databases, Selenium web browsers, or anything else that can run in a Docker container.

Stars8,657

Forks1,849

Last commit4 days ago

Community-curated · Updated weekly · 100% open source

Found a gem we're missing?

Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.

Submit a project Star on GitHub