ObjectDB Object Database Features

• Windows, Linux, Unix, Mac OS, and most other OS with Java support.
• Java 8 or higher
• Tested integration with Tomcat, Jetty, GlassFish, WildFly, Spring MVC and Spring Boot.

• Client-Server mode (TCP/IP).
• Secure Client-Server mode (SSL over TCP/IP).
• In process embedded database mode.

Capabilities and Limitations

• Database file size up to 128 TB (= 131,072 GB = 134,217,728 MB).
• Up to 2,147,483,648 entity classes per database file.
• Up to 2,147,483,648 indices per database file.
• Up to 9,223,372,036,854,775,808 entity objects per database file.
• Unlimited database connections (limited only by operating system resources).
• Unlimited CPUs and cores.

• Recovery from failure by using a recovery file and double writing.
• Additional recovery layer - supports full transaction recording and replaying.
• Automatic diagnosis and repair of corrupted database files (the ObjectDB Doctor).

• Most features of JPA 2 are supported.
• Support for remaining features is in progress - see issue tracking (requires login).

• Complete JDO 2 support (passed the JDO 2 TCK).
• Support for JDO 3 new features is in progress - see issue tracking (requires login).

• Highly optimized code (as a result of many profiling sessions).
• Unique data structures and algorithms (as a result of years of R&D).
• Outperforms competing products.

• Automatic connection pool managed by EntityManagerFactory.
• Configurable - minimum/maximum connections and timeout.

• L1 entity object cache (per EntityManager).
• L2 shared entity data cache (per EntityManagerFactory).
• Database file page cache.
• Query program cache (for repeating queries with different arguments).
• Query result cache (for repeating queries with the same arguments).
• Many other internal caches.

• Single field and multi field (composite) indices.
• Collection and array elements are indexable (extremely fast JOIN queries).
• Map keys and values are indexable.
• Nested paths inside embedded objects are indexable.
• Indices are also used for fast ordering and aggregate calculations.

• Automatic pre-loading optimizations.
• Configurable JPA eager/lazy fetch and JPA query FETCH JOIN.
• Configurable JDO fetch groupsjavax.jdo.FetchGroupJDO interfaceFetchGroup represents a named fetch group for a specific class or interface.See JavaDoc Reference Page....

• Database is a single file - easier to back up, transfer and manage.
• Single runtime JAR (including JPA/JDO) - no external dependencies.
• Simple (codeless) configuration using XML and annotations.
• Zero administration.

• Compressive, up to date, searchable online Developer's Guide/Manual.
• ObjectDB Manual in PDF format is included in ObjectDB distribution download.
• Online searchable JPA API Reference (based on JavaDoc).
• Online searchable JDO API Reference (based on JavaDoc).

• Various downloadable tutorials for Eclipse, NetBeans, IntelliJ and Maven.
• Getting Started Tutorial (console).
• Web Application Tutorial (Tomcat/Jetty).
• Java EE Web Tutorial (GlassFish/JBoss).
• Spring MVC Framework Web Tutorial.

• Easier than other JPA solutions - no need to learn and use O/R mapping.
• Easier to learn than other Object-Oriented Database Systems (ODBMS)  -
  no need to learn a proprietary API - any user with some experience with Hibernate, TopLink, EclipseLink, OpenJPA, JPOX or DataNucleus could start using ObjectDB immediately.

• SQL-like (but object based) query language - familiar to most developers.

• JPA is very simple, except for mapping, which is irrelevant to ObjectDB.

• Persistence is set using JPA/JDO annotations (e.g. @Entityjavax.persistence.EntityJPA annotationSpecifies that the class is an entity.See JavaDoc Reference Page..., @Idjavax.persistence.IdJPA annotationSpecifies the primary key of an entity.See JavaDoc Reference Page..., @Indexjavax.jdo.annotations.IndexJDO annotationAnnotation for a database index.See JavaDoc Reference Page...).
• Transparent activation (no activation depth) - objects are retrieved from the database automatically by navigating from other managed objects.
• Transparent update - changes are detected automatically.
• Code enhancement is optional (recommended before deployment).

• Fully automatic schema evolution and type versioning.
• Class hierarchy changes are handled automatically.
• New added fields are handled automatically.
• Removed fields are handled automatically.
• Most field type changes are handled automatically.
• Moving fields up and down in the class hierarchy is transparent.
• Support for renaming types, fields and properties.

• Entity classes (@Entity)
• Embeddable types (@Embeddable)
• Mapped super classes (@MappedSuperclass)
• Enum classes
• Serializable types

• Primitive types (boolean, byte, short, char, int, long, float, double).
• Wrapper types (Boolean, Byte, Short, Character, Integer, Long, Float, Double).

• java.lang.String
• Date types: java.util.Date, java.sql.Date, java.sql.Time and java.sql.Timestamp.
• Math types: java.lang.BigInteger and java.lang.BigDecimal.
• Collection types: Collection, List, Set, ArrayList, Vector, Stack, LinkedList, ArrayDeque, PriorityQueue, HashSet, LinkedHashSet, TreeSet.
• Map types: HashMap, Hashtable, WeakHashMap, IdentityHashMap, LinkedHashMap, TreeMap and Properties.
• Arrays, including multidimensional arrays.
• Any other serializable type.

• JPA callback methods and listener classes.
• JDO callback methods and listener classes.

• Hidden - primary key is automatically managed by ObjectDB with no @Id field.
• Simple primary key - a single @Id field.
• Composite primary key - multiple @Id fields or a @EmbeddedId field.

• Primitives (boolean, byte, short, char, int, long, float and double).
• Wrappers (Boolean, Byte, Short, Character, Integer, Long, Float and Double).
• java.lang.String
• Dates: java.util.Date, java.sql.Date, java.sql.Time and java.sql.Timestamp.
• Math: java.lang.BigInteger and java.lang.BigDecimal.

• Database IDs - automatic allocation of global object database IDs.
• Sequence IDs - IDs are allocated automatically by application defined sequences.
• Application IDs - primary key values are set explicitly by the application.

• JPQL - Java Persistence (JPA) Query Language - SQL like syntax.
• JDOQL - Java Data Objects (JDO) Query Language - Java/SQL like syntax.

• Dynamic query definition, including using JPA Criteria Query API.
• Static definition (named queries) in annotations (@NamedQuery) and XML.
• Query parameters for efficient reuse of one query in multiple executions.
• Result range settings (first, max) - for paging.

• SELECT (including NEW).
• FROM (including INNER JOIN, LEFT OUTER JOIN and JOIN FETCH).
• WHERE (with both JPQL and JDOQL expressions).
• GROUP BY (including HAVING and aggregates).
• ORDER BY (including ASC, DESC).
• Aggregates (COUNT, SUM, AVG, MAX, MIN).

• Path navigation expressions using the dot (.) operator.
• Comparison operators (<, <=, >=, <>, =, !=, ==, BETWEEN, IS NULL).
• Logical operators (AND, OR, NOT, &&, ||).
• Arithmetic operators & functions (+, -, *, /, %, ABS, SQRT, MOD).
• JPQL string operators & functions (LIKE, CONCAT, TRIM, SUBSTRING, ...).
• JPQL collection operators & functions (IS EMPTY, MEMBER OF, SIZE).
• Java standard methods in queries.
• User defined methods in queries.

• JPA/JDO ACID transactions.
• Operations: begin, commit, rollback.

• All API classes and interfaces are thread safe.
• Support of efficient real multithreading.
• Support of efficient real multiprocessing.

• Automatic object versioning (can be injected to a @Version field).
• Optimistic locking (always active).
• Implicit pessimistic locking (JDO).
• Explicit pessimistic locking (JPA 2).
• Always Object Level locking.
• Lock modes: READ/WRITE, OPTIMISTIC/PESSIMISTIC.

• Visual GUI tool for viewing and editing database content.
• Query execution using JPA JPQL and JDO JDOQL + query execution plan explanation.
• Schema tree for browsing the database schema (classes, fields, indices).
• Table view for browsing the content of entity objects.
• Tree view for navigating between entity objects.

• Available as Windows EXE and Unix/Linux/Mac OS executable script.
• Easily managed from a system tray icon.
• Can also be managed (started, restarted, stopped) from the command line.

• Boosts performance by avoiding reflection and by using smart tracking.
• Non enhanced classes are also supported (by using reflection).
• On the fly enhancement by using a Java agent.

• Master-Slave replication (clustering) with an unlimited number of slave nodes.
• Dynamic composite database connections for high availability and fault tolerance.

• Online backup by a simple query on an EntityManager/PersistenceManager.
• Supports automatic download of created backups from the server to the client.

• Diagnoses if a database file is healthy and identifies possible problems.
• Automatically repairs damaged database files with minimum data loss (if any).

• Transactions and database operations can be recorded.
• Recorded operations can be replayed starting from a database snapshot.

• ObjectDB databases are valid BIRT data sources.
• BIRT data sets can be defined using JPA and JDO queries (JPQL, JDOQL).