Object Relational Mapping system
Current Version: 2.9.2
- Profiling: Some refactoring and memory use improving
- Cashe: Improved TSCashe and checked in real project(NOMAD CFM (electronic queue))- impressive results
- Faster: As usual
- Usability: Chain syntax of snip expressions for usability.
- Transactions: Improved transaction processing
- Relative paths: Introduced a relative paths of properties files for use with spring and other frameworks
- Reliability: More tests.
- Pipe data: Improved a heterogeneous data pipe between different DB.
- Faster: 30% faster.
- Usability: Static wrappers, factories for improving usability.
- DQL: Now if you are not like DataSnip's you may use any complicated SQL queries
with smooth unintrusive syntax - just string without concatenation of class names or something else, even simpler
than particular SQL queries - just use only aliases everywhere... it looks
like: 'SELECT c.* FROM c WHERE c.offerId in ( SELECT o.id FROM o WHERE o.userId in (select u.id from u where u.firstName = ?))'
- Distributed transactions with different databases:
Even distributed transactions with different darabases now improved!
- Faster: It was refactored for a smaller size and a faster work.
- Code coverage: 100 percent Public methods test coverage.
Around 80 percent test coverage of ALL instructions.
- Reliability: Ten tests joined in the test suite for a different directions
of functionality - common functionality, multithreading, JPA standarts,proxy interception, zero configuration(even without @Entity - annotation)
Backup any databases and a different caching.
- Simplisity: More simple start method Was added for a more options of start. Even without a Eclipse IDE.
Working with any classes without any mappings and annotations
You may just send any objects and they will be mapped and processed on the fly. There is example - CarZeroTest - a testers or beginners may use
it even without loading and installing any databases - h2 database included - and later transfer it into any other database
- JPA mapping: Supports allmost all annotations - two examples for tests was taken from JSR220
- EHCache and JBoss cache wrappers: You may use default included cache or discover the most powerful solutions
- Unintrusive linking: The all references to linked in runtime object will be saved apart automatically
via cross tables. Beside of details - just save complex objects and it will be saved and restored with all inner objects
- Proxy: Interception getters and setters of any classes even do not implements any interfaces
- Backup and restore: Now you may to backup any database with one simple instrument as whole as apart.
Sure - it is not so strong and accurate how backup tools from manufacturers, but it do not require any exclusive access rights - only for read.
- Modularity: You may to work with any database just to put wright plugin into plugins directory
of you aplication. Now available plugins for Oracle,DB2,MSSQl,MySql,PostgreSql,Derby,H2
- Eclipse extension point based mapping: You can be escaped from writing XML tags by hand or spoil you
code with a big amount of annotations. And you can to change mapping without compilation
- Pump heterogenous data: You may to connect to many databases and to pump data between them
- Logging operations: You may to log any DML operations by standartized form in to one database and
then invoke it for another of any type
- Creation tables: Automatically creation minimal table structure according with mapping and customize it if
- Select heterogenous data: You can select complicated heterogenous data structures related with some business process(binded
or unbinded to each other) during one call
of the datascooter. Then you can serialize or save this structures in. to another database. You application
can not have any information about classes required for this business process - you may not implement
unknown classes but can invoke and manupulate related data
- Flexible mapping: You can to create and change mapping in runtime,so you can work with not yet mapped objects
- Not only Object-Relational: You can to work with set of data not only predefined classes: You can map entity without java class
and manupulate with this named set of data like class in other ORM systems - select,insert,delete...
- Persistable child: You can to work with objects contained other objects or maps,lists,sets or arrays
of other mapped objects
- Inheritance: You can select only parent objects, only children or both - what you want in runtime
- Pagination: If a set of data is too big - you can use pagination even databse do not know about it
- Logic Attributes: You may to separate entities in one table with complicated logical
explessions even change type of object depends of result of calculation of expresion
- Query: You may to define through extension points a predefined queries
- Partial selection: You may to select not whole object but define which fields required
in this moment or which not
- --------------Since version 2.7-------------
- References: Lazy loading embedded objects
- Zero config: Automatically creation of mapping allows to work with unmapped beforehand classes
- JPA Implementation: Work with JPA annotations and building a mapping in runtime
- Transactions: Simple and distributed transactions with two-phase commit
- Container Attributes: Saving of any embedded objects even without relational links
- Entity Parts: Composite entities builded from different tables
Awards of related software