JDXA Datasheet

JDXA (JDX for Android) is a flexible, non-intrusive, developer-friendly, and lightweight Object-Relational Mapping (ORM) solution for seamlessly bridging the gap between the Java object model and SQL relational model for mobile applications. JDXA increases programmer productivity tremendously by presenting a more intuitive, object-oriented view of relational data and eliminating the need to write endless lines of complex low-level SQL code.  

Based on some well thought-out KISS (Keep It Simple and Straightforward) principles, JDXA provides fast, flexible, and easy-to-use ORM functionality in a small footprint. JDXA employs a clean, dynamic, and meta-data driven programming methodology supporting pure domain object models, resulting in simpler and faster applications that are easy to evolve and maintain.

The product comes with Android platform-specific utility classes to facilitate the easy and speedy development of mobile applications that need on-device access to SQLite relational database.

JDXA Features:

Please click on any of the following features to learn more.

Declarative mapping specification based on simple grammar
  • Human-readable and easily comprehensible; no need to struggle with complex XML files.
  • Compact; most default mapping is automatically deduced; avoids verbosity.
  • Most mapping primitives are orthogonal to each other, avoiding unnecessary tight coupling and enabling easy evolution.
  • Allows cross-referencing of classes and collections no matter in which order their mappings have been defined.
  • Intuitive and flexible ways of mapping complex object structures.
  • Mappings for collections and relationships are defined at the object level, not at the relational level; makes it easier to understand and modify such mappings.
A non-intrusive and dynamic programming model
  • Supports POJO (Plain Old Java Object) classes for persistence.
  • No requirement to inherit from a special class.
  • No generation of complex source code for data access methods.
  • Allows easy evolution of object and relational models.
  • Supports explicit transactions
Easily handles complex object structures, including class-hierarchies.
  • Associative and aggregated relationships.
  • 1-to-1, 1-to-many, and many-to-many relationships.
  • Aggregated or separated tables options for storing objects in a class-hierarchy.
  • Support for persisting JSON objects.
Flexible query options – deep, shallow, and anything in-between
  • Supports loading of partial objects.
  • Sophisticated query predicates (including path-expressions).
  • Powerful object-streaming functionality.
  • Polymorphic queries.
  • Persistence-by-reachability.
  • Dynamic data routing.
  • Named queries for greater convenience, more flexibility, and better performance.
  • No learning of any new query language required.
Virtual attributes
  • Allows mapping of class attributes, which are not explicitly declared in the class definition.
  • Enables flexible evolution of object/data modeling in many situations.
Aggregate operations
  • Returns the aggregate value (COUNT, MIN, MAX, AVG, SUM) for the specified attribute of the qualifying objects. Enables easy data analysis.
Object caching
  • Provides super-fast access to business objects from high-performance memory cache.
  • Regular and LRU caches.
Flexible Support for Multiple Mappings and Multiple Databases
  • An App may easily employ multiple mapping specifications for flexible and modular partitioning of mapping units
  • An App may work with multiple Databases simultaneously
Optimistic locking for concurrency control
  • Provides a faster and more scalable locking alternative to database. locking. Especially useful for long-running transactions with minimal conflicting update operations.
Lightweight and optimized mapping engine
  • Self-healing connection pooling. 
  • Use of prepared statements.
  • Optimized SQL statements.
  • Minimal database trips. 
  • Short code paths.
  • Small footprint. 
  • Accelerates data exchange.
Automatic Schema generation
  • JDX automatically creates the database schema (tables, constraints, etc.) as per the Java object model and the object-relational mapping specification.
Nifty components and facilities to simplify development
  • Utility components for pooling JDX handles.
  • Persistently unique sequence generators. 
  • Object-viewing facilities. 
  • Support for instance callback methods.
  • Configurable logging destination
Easy-to-learn and easy-to-use
  • Clean design – not an over-engineered framework with complex semantics.
  • Small set of simple and flexible APIs.
  • No learning of new query language required.
  • Meaningful error and debug messages.
Extensive documentation
  • A comprehensive manual, many tutorials and working examples.