Major upgrade of LLBLGen Pro released!

After 3 months of hard work, today, a major upgrade of one of the leading O/R mappers for .NET, LLBLGen Pro, has been released! . A large amount of new features are added to the new runtime libraries and templates, among them: MS Access 2000/XP/2003 support, prefetch paths, paging in entity collections and lists, aggregate function support and sql expression support and much more. Below is the full list of new things.

This upgrade is of course free for our customers .

Runtime Libraries

Added
  • Adapter/SelfServicing: MS Access support.
  • Adapter/SelfServicing: entityCollection.Sort(fieldIndex), to sort the collection in memory.
  • Adapter/SelfServicing: GroupByCollection support for typed lists/typed views and datatable fetched dynamic lists
  • Adapter/SelfServicing: HAVING Clause support to the GroupByCollection
  • Adapter/SelfServicing: Aggregate function support on IEntityField(2) objects (entity/typedlist/typedview). An IEntityField(2) instance can have an aggregate function applied to it, which is added to the field's SQL at runtime in Selects. Not all aggregate functions defined are supported on all supported database types.
  • SelfServicing: entityCollection.GetDbCount() (overloaded) to retrieve the amount of entities in the database of a given entity type and optionally with a given filter
  • Adapter/SelfServicing: GetScalar() (overloaded) method to retrieve a scalar value from the database without the necessity of creating an entity or typed list. Adapter users should use GetScalar to get the equivalent of GetDbCount()
  • Adapter/SelfServicing, SqlServer specific: SET ARITHABORT ON/OFF setting so inserts can be done in tables which are part of indexed views.
  • Adapter: COM+ support. See ComPlusAdapterContext class in the database specific project for more information.
  • Adapter/SelfServicing: SQL Expression support for field values. An IEntityField(2) instance now has a property which can be set to an Expression instance. This will make the field be replaced by the SQL representation of the expression. You can use this to create a field value for an entity or typed list or typed view be set to the result of an SQL Expression instead of the actual field value. This also works for updates done directly on the database.
  • Adapter/SelfServicing: Paging support for collections/typed lists/typed views. Paging support is added to the fetch routines and various overloads of these fetch routines. Specify the page size and page number to retrieve a subset of the entities to retrieve.
  • Adapter/SelfServicing: IEntityField(2).IsForeignKey has been added.
  • Adapter/SelfServicing: IEntityField(2).DbValue has been added. This is the value the field had when it was read from the database. You can use this property in your Optimistic concurrency predicates.
  • Adapter/SelfServicing: UnitOfWork(2) class. You can use this class to collect work to be done (on a single database, for multiple database actions, use a UnitOfWork(2) object per database)
  • Adapter/SelfServicing: SavePoint support for ADO.NET transactions. Use this to save a transaction under a given name, so a rollback can be done to the state at the time the transaction was saved.
  • Adapter, Oracle specific: Schema name overwrite logic implemented like SqlServer has for Catalog names.
  • Adapter/SelfServicing: Prefetch paths. Various fetch routines (and entity instantiation constructors (selfservicing)) support Prefetch paths. A prefetch path is a graph definition of related entities to fetch together with the actual entity / entities to fetch. Prefetch paths form an efficient way to pull related data out of the database without the requirement to create a query per entity. Prefetch paths support filtering, sorting and support limitation on the amount of objects to return per parent entity. Prefetch paths result in 1 query per entity type, so fetching all orders with their related customers, will result in 2 queries, which are merged by the runtime library code. All relation types are supported, intermediate entities are not prefetched.
  • Adapter/SelfServicing: Multi-level versioning of entity fields. You can now save an entity's fields under a name inside the entity and roll back to that state later.
  • Adapter/SelfServicing, SqlServer specific: FieldFullTextSearchPredicate, to perform full text searches on SqlServer databases which have Full text search enabled.
  • Adapter/SelfServicing: FieldCompareExpressionPredicate. This predicate can formulate field operator value/expression/field or value/expression/field operator field or value/expression/field operator expression/field filters.
  • Adapter/SelfServicing: FieldCompareSetPredicate. This predicate allows you to formulate field operator (subquery) filters. Operators include IN/comparison operators/EXISTS, ALL/ANY operators and all negative equivalents. Field can contain an expression / aggregate as well which is applied at runtime to the field.
  • Adapter/SelfServicing: entities can be joined multiple times to a join set. An alias for the entity has to be specified with the specification of the relation when it is added to a RelationCollection (or RelationPredicateBucket). The alias can also be specified with predicate instances to make filters work on a particular instance of the joined entity in the join list.
  • Adapter/SelfServicing: entities can be joined with self. This is the result of the multiple times an entity can be joined to a join set.
  • Adapter/SelfServicing: A JoinHint can now be specified when relations are added to a RelationCollection, for more fine grained control over what to use: left/right/inner joins.
Changed
  • Adapter: When a new entity is saved and the entity has a sequenced PK field and the entity isn't refetched, the new value for the PK is retrievable, despite the fact that the entity itself is marked OutOfSync.
  • Adapter/SelfServicing: For non-new entities: when a field is set to the value the field already has, the field is not marked changed if the field wasn't marked changed already.
  • Adapter/SelfServicing: All custom exception classes are now derived from ORMException which derives from ApplicationException.
  • Adapter/SelfServicing: PK fields of non-new entities can now be changed to a new value. This is not true for sequenced PK fields, these stay read-only.
  • Adapter/SelfServicing: Like predicates can now do case insensitive comparisons when it is necessary to do so. A case insensitive compare compares the UPPERCASE variant of the field with the pattern specified.

Templates

Added
  • SelfServicing: Entity classes now have a flag MappedFieldOnRelationReturnsNewIfNotFound. This flag, default set to true, can be used to signal lazy loading code to return null / Nothing when a related entity is not found in the database (m:1, 1:1 relations). Before, always a new, empty entity was returned when the related entity was not found. The flag is set to true by default to prevent code breakage.
  • SelfServicing: GeneralEntityFactory class, which generates an EntityFactory instance for the entity type specified.
  • SelfServicing: DbUtils now has the property ActualConnectionString, which can be set at runtime to overwrite the connection string to use. This setting is global and is used by all calls in the application.
  • SelfServicing: Stored procedure calls can now be done in an active transaction.
Changed
  • Adapter / SelfServicing Template set structures are changed, all shared templates are now stored in a SharedTemplates folder.
  • SelfServicing: When GetMultiManyToOne() is called with solely null / Nothing values for the related entities, GetMulti() is called instead.
  • Adapter/SelfServicing: RelationsetFields is updated to support aliases for entities as well as aggregates and expressions
  • Adapter: DataAccessAdapter methods which call stored procedures are made virtual.
  • SelfServicing: entityFactory.Create()'s internal contents is now an included template. This opens the door for more customized instantiation of entities during multi-entity fetches.
  • Adapter/SelfServicing: Typed lists / typed views now return the default value for the type of the field if that field's value is NULL
  • Adapter/SelfServicing: When an FK field is set to a different value, the referenced entity by that FK value is set to null/Nothing

9 Comments

  • Now I just have to convince my employers to buy it (or buy it myself, use it to do a bunch of my work and head off down the pub with the time I save :-))

  • Hi Frans,



    All I can say is wow. I know how hard you've been working on LLBLGen and it gets better and better.



    Thanks for making such a great product at such an affordable price.



    For those of you who haven't used LLBLGen I recommend you download the trial and give it a trial. You will not regret it!



    John

  • Just wanted to add my congratulations as well.



    I bought LLBLGen Pro on a whim when it first came out based solely on your professional character and it has turned out to be an invaluable tool.



    You have the recipe for success and other vendors should take note:



    :: Feature-Rich and Stable Product.

    :: Frequent Quality Updates.

    :: Timely Support.

    :: Affordable Price.



    Thanks for all your effort on the product and in the developer community!

  • Congrats on another great version.

  • Thanks guys! :)



    Yeah, I have the feeling it more and more becomes what I had in mind when I started the project late 2002 :). We're not there yet, the designer has to get a lot of designer goodies to make life easier as well etc.. but this upgrade adds so much value to the tool :) With every feature I wondered "why haven't I added this in the first place? " ;)



    Next up are a couple of more databases to support. But first a couple of days with not that much coding :).

  • Looks very cool! You just might have the coolest O/R mapper for the .net platform here ;-) I especially like the added support for eager/lazy loading. Just about the only thing that I'm missing is better support for inheritance. I know that you can code you way through it but it would be nice with support build-in for it I think. Is that something you envision for a future release?

  • "I especially like the added support for eager/lazy loading"

    Lazy loading was already present, in SelfServicing, but Adapter didn't have it (because it uses a separate adapter object to do the persistence, so in a remoted scenario you'd be out of luck). Prefetch paths solve this, just specify the tree to fetch, including filters, sorting and limitation on size, and pull the entities out of the db in one query per type :)



    "Just about the only thing that I'm missing is better support for inheritance. I know that you can code you way through it but it would be nice with support build-in for it I think. Is that something you envision for a future release?"

    Inheritance is somewhat lacking indeed at the moment. It is planned though, but we wanted to create the more important features first. Inheritance is often mentioned as an essential requirement for O/R mapping, however it's often not that of a problem if inheritance isn't there, as data in a relational database is more flexible to use when it is not fit in an inheritance model. (person <- customer, person <- employee, employee buys something.. oops :))



    But it is added in the near future.

  • Frans, congrats!! One thing I've always wondered is, are there any other O/R mappers out there that you hold in high regard, for example in the Java world (since there seem to be hundreds there).

  • The java world is not comparable with the .NET world. This is because in the java world you use an application server and you 'plug-in' the O/R mapper of choice but it's mostly transparent. (you can also use an O/R mapper separately of course). A lot of people like and use hibernate, which looks impressive from the featurelist but I haven't used it myself. Internally hibernate does some things we can't do in .NET (overwrite bytecode for property getter/setters) and for value change tracking for example it isn't that efficient.



    One of the top O/R mappers is of course Toplink, by Oracle. The gui isn't that great, but its featureset is very good.

Comments have been disabled for this content.